@floristcloud/api-lib 1.2.179 → 1.2.181

package/commands/settings/index.ts

@@ -2,3 +2,5 @@ export * from './get-settings.query';
 export * from './update-settings.command';
 export * from './get-settings-for-admin.query';
 export * from './get-company-profile.query';
+export * from './get-settings-private.query';
+export * from './update-settings-private.command';

package/commands/settings/update-settings-private.command.ts

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

package/constant/error.ts

@@ -234,6 +234,34 @@ export const ERRORS = {
     BRANCH_NOT_FOUND: { code: 'B004', message: 'Branch not founded', httpCode: 404 },
     BRANCH_NOT_DELETED: { code: 'B005', message: 'Branch not deleted', httpCode: 500 },
     BRANCH_NOT_UPDATED: { code: 'B006', message: 'Branch not updated', httpCode: 500 },
+    // MEASURE_UNIT
+    MEASURE_UNIT_NOT_FOUND: { code: 'MU001', message: 'Measure unit not found', httpCode: 404 },
+    MEASURE_UNIT_NAME_EXISTS: { code: 'MU002', message: 'Measure unit name is already used', httpCode: 409 },
+    MEASURE_UNIT_SHORT_NAME_EXISTS: { code: 'MU003', message: 'Measure unit short name is already used', httpCode: 409 },
+    MEASURE_UNIT_ALIAS_CONFLICT: { code: 'MU004', message: 'Measure unit alias overlaps another unit', httpCode: 409 },
+    MEASURE_UNIT_INVALID_OKEI: { code: 'MU005', message: 'OKEI code must contain three digits', httpCode: 400 },
+    MEASURE_UNIT_DEFAULT_ARCHIVE: { code: 'MU006', message: 'Cannot archive the default measure unit', httpCode: 400 },
+    MEASURE_UNIT_ARCHIVED_DEFAULT: { code: 'MU007', message: 'Cannot make an archived measure unit default', httpCode: 400 },
+    MEASURE_UNIT_ARCHIVED: { code: 'MU008', message: 'Measure unit is archived', httpCode: 400 },
+    MEASURE_UNIT_INVALID_ORDER: {
+        code: 'MU009',
+        message: 'Measure unit order must contain all units or all active units exactly once',
+        httpCode: 400,
+    },
+    MEASURE_UNIT_FAILED: { code: 'MU010', message: 'Failed to process measure units', httpCode: 500 },
+    MEASURE_UNIT_INVALID_NAME: { code: 'MU011', message: 'Measure unit names must not be empty', httpCode: 400 },
+    MEASURE_UNIT_ALREADY_LINKED: { code: 'MU012', message: 'Measure unit is already linked to another external unit', httpCode: 409 },
+    MEASURE_UNIT_INVALID_TEXT: {
+        code: 'MU013',
+        message: 'Measure unit names or aliases exceed limits or contain control characters (name/alias: 100, short name: 32, aliases: 50)',
+        httpCode: 400,
+    },
+    MEASURE_UNIT_LIMIT_EXCEEDED: {
+        code: 'MU014',
+        message: 'Company may have at most 100 measure units, including archived units',
+        httpCode: 400,
+    },
+
     //PRODUCT
     PRODUCT_NOT_CREATED: { code: 'P001', message: 'Failed to create product', httpCode: 500 },
     PRODUCT_FETCH_FAILED: { code: 'P002', message: 'Error when retrieving a product', httpCode: 500 },

package/constant/index.ts

@@ -16,3 +16,4 @@ export * from './client-group-actions.constant';
 export * from './standing-order-positions.constant';
 export * from './order-external-number.constant';
 export * from './discount-rules-pricing-type-list.constant';
+export * from './measure-unit-limits';

package/constant/measure-unit-limits.ts

@@ -0,0 +1 @@
+export const MEASURE_UNIT_LIMITS = { name: 100, shortName: 32, alias: 100, aliases: 50, perCompany: 100 };

package/enum/external-entity-type.enum.ts

@@ -1,4 +1,5 @@
 export enum ExternalEntityTypeEnum {
+    MEASURE_UNIT = 'MEASURE_UNIT',
     PRODUCT = 'PRODUCT',
     CATEGORY = 'CATEGORY',
     CLIENT = 'CLIENT',

package/enum/index.ts

@@ -55,6 +55,7 @@ export * from './language.enum';
 export * from './legal-identifier-field.enum';
 export * from './match-confidence.enum';
 export * from './moysklad-sync-status.enum';
+export * from './moysklad-import-item-status.enum';
 export * from './normalization-decision-action.enum';
 export * from './normalization-target.enum';
 export * from './normalization-value-state.enum';
@@ -162,3 +163,4 @@ export * from './pre-order-fulfillment-status.enum';
 
 export * from './delivery-pricing-rule-scope.enum';
 export * from './delivery-pricing-in-transit-mode.enum';
+export * from './measure-unit-match-source.enum';

package/enum/measure-unit-match-source.enum.ts

@@ -0,0 +1,6 @@
+export enum MeasureUnitMatchSourceEnum {
+    LINK = 'LINK',
+    OKEI = 'OKEI',
+    NAME = 'NAME',
+    DEFAULT = 'DEFAULT',
+}

package/enum/moysklad-import-item-status.enum.ts

@@ -0,0 +1,6 @@
+// Строка предпросмотра импорта из МойСклада: NEW — в FC ещё нет, создастся; KNOWN — уже связана ссылкой.
+// Значения в нижнем регистре — так их уже шлёт и сравнивает fc-app.
+export enum MoyskladImportItemStatusEnum {
+    NEW = 'new',
+    KNOWN = 'known',
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@floristcloud/api-lib",
-    "version": "1.2.179",
+    "version": "1.2.181",
     "description": "",
     "main": "./build/index.js",
     "scripts": {

package/schemas/client/client-filters-values.schema.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+
+export const ClientFiltersValuesSchema = z.object({
+    groupList: z.array(z.string()).optional(),
+    cityList: z.array(z.string()).optional(),
+});

package/schemas/client/get-client-filters-values-request.schema.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+
+export const GetClientFiltersValuesRequestSchema = z.object({
+    companyUUID: z.string().uuid().optional(),
+});

package/schemas/client/get-client-filters-values-response.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { ClientFiltersValuesSchema } from './client-filters-values.schema';
+
+export const GetClientFiltersValuesResponseSchema = z.object({
+    message: z.string().optional(),
+    data: ClientFiltersValuesSchema,
+});

package/schemas/client/index.ts

@@ -30,3 +30,6 @@ export * from './update-client-for-client-response.schema';
 export * from './client-extended-list.schema';
 export * from './client-extended.schema';
 export * from './legal-identifier-value.schema';
+export * from './client-filters-values.schema';
+export * from './get-client-filters-values-request.schema';
+export * from './get-client-filters-values-response.schema';

package/schemas/consignment/consignment-product-multiplicity-option-update.schema.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { MoneySchema } from '../money.schema';
+
+export const ConsignmentProductMultiplicityOptionUpdateSchema = z.object({
+    title: z.string().nullable().optional(),
+    optionMultiplicity: z.number().nullable().optional(),
+    optionPrice: MoneySchema.nullable().optional(),
+    // Отсутствие поля — флаг не меняем; у создаваемой кратности берётся умолчание (скидки разрешены).
+    // Пустая ячейка в файле сюда не доезжает: разбор превращает её в отсутствие поля, а не в `false`.
+    isDiscountAllowed: z.boolean().optional(),
+});

package/schemas/consignment/consignment-product-position-update.schema.ts

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+import { SalesUnitEnum } from '../../enum/sales-unit.enum';
+import { MoneySchema } from '../money.schema';
+import { ConsignmentProductMultiplicityOptionUpdateSchema } from './consignment-product-multiplicity-option-update.schema';
+
+export const ConsignmentProductPositionUpdateSchema = z.object({
+    measureUnitUUID: z.string().uuid().optional(),
+    salesUnit: z.nativeEnum(SalesUnitEnum).nullable().optional(),
+    measureUnitText: z.string().nullable().optional(),
+    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: ConsignmentProductMultiplicityOptionUpdateSchema.nullable().optional(),
+    option2: ConsignmentProductMultiplicityOptionUpdateSchema.nullable().optional(),
+});

package/schemas/consignment/execute-consignment-product-update-request.schema.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+import { ConsignmentProductPositionUpdateSchema } from './consignment-product-position-update.schema';
+
+export const ExecuteConsignmentProductUpdateRequestSchema = z.object({
+    updates: z.record(z.string(), ConsignmentProductPositionUpdateSchema),
+});

package/schemas/consignment/execute-consignment-product-update-response-data-errors.schema.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+import { ErrorMessageSchema } from '../error-message.schema';
+
+export const ExecuteConsignmentProductUpdateResponseDataErrorsSchema = ErrorMessageSchema.extend({
+    uuid: z.string(),
+});

package/schemas/consignment/execute-consignment-product-update-response-data.schema.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { ExecuteConsignmentProductUpdateResponseDataErrorsSchema } from './execute-consignment-product-update-response-data-errors.schema';
+
+export const ExecuteConsignmentProductUpdateResponseDataSchema = z.object({
+    unrecognizedMeasureUnitCount: z.number(),
+    unrecognizedMeasureUnitExamples: z.array(z.string()),
+    success: z.boolean(),
+    successCount: z.number(),
+    failedCount: z.number(),
+    errors: z.array(ExecuteConsignmentProductUpdateResponseDataErrorsSchema),
+});

package/schemas/consignment/execute-consignment-product-update-response.schema.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+import { ExecuteConsignmentProductUpdateResponseDataSchema } from './execute-consignment-product-update-response-data.schema';
+
+export const ExecuteConsignmentProductUpdateResponseSchema = z.object({
+    data: ExecuteConsignmentProductUpdateResponseDataSchema,
+});

package/schemas/consignment/import-consignment-request-constant-data.schema.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { ConsignmentImportSchemaRelationEntityPropertyEnum } from '../../enum';
+
+export const ImportConsignmentRequestConstantDataSchema = z.object({
+    [ConsignmentImportSchemaRelationEntityPropertyEnum.INVOICE_NUMBER]: z.string().nullable().optional(),
+    [ConsignmentImportSchemaRelationEntityPropertyEnum.GROWER]: z.string().nullable().optional(),
+    [ConsignmentImportSchemaRelationEntityPropertyEnum.COUNTRY]: z.string().nullable().optional(),
+});

package/schemas/consignment/import-consignment-request.schema.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import { ConsignmentImportNameConventionEnum } from '../../enum';
+import { ImportConsignmentRequestConstantDataSchema } from './import-consignment-request-constant-data.schema';
+
+export 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: ImportConsignmentRequestConstantDataSchema.optional(),
+});

package/schemas/consignment/import-consignment-response-data-warnings.schema.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { DataNotExistsSchema } from './consignment.schema';
+import { ProductErrorTypeSchema } from './consignment.schema';
+
+export const ImportConsignmentResponseDataWarningsSchema = z.object({
+    row: z.number(),
+    errors: z.array(z.union([ProductErrorTypeSchema, DataNotExistsSchema])),
+});

package/schemas/consignment/import-consignment-response-data.schema.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { ImportConsignmentResponseDataWarningsSchema } from './import-consignment-response-data-warnings.schema';
+
+export const ImportConsignmentResponseDataSchema = z.object({
+    success: z.boolean(),
+    rows: z.number(),
+    unrecognizedMeasureUnitCount: z.number(),
+    unrecognizedMeasureUnitExamples: z.array(z.string()),
+    warnings: z.array(ImportConsignmentResponseDataWarningsSchema),
+});

package/schemas/consignment/import-consignment-response.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { ImportConsignmentResponseDataSchema } from './import-consignment-response-data.schema';
+
+export const ImportConsignmentResponseSchema = z.object({
+    message: z.string().optional(),
+    data: ImportConsignmentResponseDataSchema,
+});

package/schemas/consignment/import-packing-consignment-request.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+
+export 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),
+});

package/schemas/consignment/import-packing-consignment-response-data-warnings.schema.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import { DataNotExistsSchema } from './consignment.schema';
+import { ProductErrorTypeSchema } from './consignment.schema';
+
+export const ImportPackingConsignmentResponseDataWarningsSchema = z.object({
+    row: z.number(),
+    productUUID: z.string().uuid().optional(),
+    errors: z.array(z.union([ProductErrorTypeSchema, DataNotExistsSchema])),
+});

package/schemas/consignment/import-packing-consignment-response-data.schema.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { ImportPackingConsignmentResponseDataWarningsSchema } from './import-packing-consignment-response-data-warnings.schema';
+
+export const ImportPackingConsignmentResponseDataSchema = z.object({
+    success: z.boolean(),
+    rows: z.number(),
+    unrecognizedMeasureUnitCount: z.number(),
+    unrecognizedMeasureUnitExamples: z.array(z.string()),
+    warnings: z.array(ImportPackingConsignmentResponseDataWarningsSchema),
+});

package/schemas/consignment/import-packing-consignment-response.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { ImportPackingConsignmentResponseDataSchema } from './import-packing-consignment-response-data.schema';
+
+export const ImportPackingConsignmentResponseSchema = z.object({
+    message: z.string().optional(),
+    data: ImportPackingConsignmentResponseDataSchema,
+});

package/schemas/consignment/index.ts

@@ -0,0 +1,16 @@
+export * from './import-consignment-request-constant-data.schema';
+export * from './import-consignment-request.schema';
+export * from './import-consignment-response-data-warnings.schema';
+export * from './import-consignment-response-data.schema';
+export * from './import-consignment-response.schema';
+export * from './import-packing-consignment-request.schema';
+export * from './import-packing-consignment-response-data-warnings.schema';
+export * from './import-packing-consignment-response-data.schema';
+export * from './import-packing-consignment-response.schema';
+
+export * from './consignment-product-multiplicity-option-update.schema';
+export * from './consignment-product-position-update.schema';
+export * from './execute-consignment-product-update-request.schema';
+export * from './execute-consignment-product-update-response-data-errors.schema';
+export * from './execute-consignment-product-update-response-data.schema';
+export * from './execute-consignment-product-update-response.schema';

package/schemas/index.ts

@@ -107,6 +107,8 @@ export * from './report/user-activity-summary-row.schema';
 export * from './report/user-activity-timeline-row.schema';
 export * from './service/service.schema';
 export * from './settings/settings.schema';
+export * from './settings/settings-private.schema';
+export * from './settings/settings-private-response.schema';
 export * from './settings/city-delivery-pricing-rule.schema';
 export * from './settings/default-delivery-pricing-rule.schema';
 export * from './settings/group-delivery-pricing-rule.schema';
@@ -127,3 +129,17 @@ export * from './write-off/write-off-archive-file.schema';
 export * from './write-off/write-off-export.schema';
 export * from './write-off/write-off-list.schema';
 export * from './write-off/write-off.schema';
+export * from './measure-unit';
+
+export * from './integration/one-c/update-one-c-settings-request.schema';
+export * from './integration/one-c/update-one-c-settings-response.schema';
+
+export * from './report/measure-unit-quantity.schema';
+
+export * from './consignment';
+
+export * from './product/group';
+
+export * from './report';
+
+export * from './integration/moysklad';

package/schemas/integration/moysklad/execute-moysklad-import-request.schema.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import { MEASURE_UNIT_LIMITS } from '../../../constant/measure-unit-limits';
+import { MoyskladMeasureUnitMappingSchema } from './moysklad-measure-unit-mapping.schema';
+import { MoyskladExecutableItemSchema } from './moysklad-executable-item.schema';
+
+export const ExecuteMoyskladImportRequestSchema = z.object({
+    measureUnitMapping: z
+        .array(MoyskladMeasureUnitMappingSchema)
+        .max(MEASURE_UNIT_LIMITS.perCompany, 'MeasureUnit.mapping.max')
+        .refine(items => new Set(items.map(item => item.externalId)).size === items.length, 'Duplicate externalId')
+        .optional(),
+    items: z.array(MoyskladExecutableItemSchema),
+    missingExternalIds: z.array(z.string()).default([]),
+    orphanedExternalIds: z.array(z.string()).default([]),
+});

package/schemas/integration/moysklad/execute-moysklad-import-response-data.schema.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { MoyskladMeasureUnitAliasAddedSchema } from './moysklad-measure-unit-alias-added.schema';
+
+export const ExecuteMoyskladImportResponseDataSchema = z.object({
+    measureUnitAliasesAdded: z.array(MoyskladMeasureUnitAliasAddedSchema),
+    created: z.number(),
+    updated: z.number(),
+    archived: z.number(),
+    orphansCleaned: z.number(),
+    consignmentUUID: z.string(),
+});

package/schemas/integration/moysklad/execute-moysklad-import-response.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { ExecuteMoyskladImportResponseDataSchema } from './execute-moysklad-import-response-data.schema';
+
+export const ExecuteMoyskladImportResponseSchema = z.object({
+    message: z.string().optional(),
+    data: ExecuteMoyskladImportResponseDataSchema,
+});

package/schemas/integration/moysklad/index.ts

@@ -6,3 +6,21 @@ export * from './moysklad-order-state-mapping.schema';
 export * from './moysklad-order-state-mapping.type';
 export * from './moysklad-status.schema';
 export * from './moysklad-sync-dead-info.schema';
+
+export * from './moysklad-scanned-item.schema';
+export * from './moysklad-category-match.schema';
+export * from './scan-moysklad-import-response-data-categories.schema';
+export * from './scan-moysklad-import-response-data-summary.schema';
+export * from './scan-moysklad-import-response-data.schema';
+export * from './scan-moysklad-import-response.schema';
+export * from './moysklad-executable-item.schema';
+export * from './execute-moysklad-import-request.schema';
+export * from './execute-moysklad-import-response-data.schema';
+export * from './execute-moysklad-import-response.schema';
+export * from './moysklad-measure-unit-link-mapping.schema';
+export * from './moysklad-measure-unit-create-mapping.schema';
+export * from './moysklad-measure-unit-mapping.schema';
+export * from './moysklad-scanned-measure-unit.schema';
+
+export * from './moysklad-measure-unit-alias-added.schema';
+export * from './moysklad-measure-unit-dictionary-item.schema';

package/schemas/integration/moysklad/moysklad-category-match.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+
+export const MoyskladCategoryMatchSchema = z.object({
+    fcCategoryUUID: z.string(),
+    fcCategoryName: z.string(),
+    itemsCount: z.number(),
+});

package/schemas/integration/moysklad/moysklad-executable-item.schema.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+import { MoyskladImportItemStatusEnum, SalesUnitEnum } from '../../../enum';
+import { MoneySchema } from '../../money.schema';
+
+export const MoyskladExecutableItemSchema = 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(),
+    measureUnitExternalId: z.string().nullable().optional(),
+    measureUnitUUID: z.string().uuid().optional(),
+    uomCode: z.string().nullable().optional(),
+    uomName: z.string().nullable().optional(),
+    salesUnit: z.nativeEnum(SalesUnitEnum).nullable().optional(),
+    status: z.nativeEnum(MoyskladImportItemStatusEnum),
+    internalUUID: z.string().nullable(),
+    resolvedCategoryUUID: z.string().nullable(),
+    resolvedImageUUID: z.string().nullable(),
+});

package/schemas/integration/moysklad/moysklad-measure-unit-alias-added.schema.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+
+export const MoyskladMeasureUnitAliasAddedSchema = z.object({
+    measureUnitUUID: z.string().uuid(),
+    alias: z.string(),
+});

package/schemas/integration/moysklad/moysklad-measure-unit-create-mapping.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { CreateMeasureUnitRequestSchema } from '../../measure-unit/create-measure-unit-request.schema';
+
+export const MoyskladMeasureUnitCreateMappingSchema = CreateMeasureUnitRequestSchema.omit({ aliases: true }).extend({
+    externalId: z.string().min(1),
+    action: z.literal('CREATE'),
+});

package/schemas/integration/moysklad/moysklad-measure-unit-dictionary-item.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { MeasureUnitShortSchema } from '../../measure-unit/measure-unit-short.schema';
+
+export const MoyskladMeasureUnitDictionaryItemSchema = MeasureUnitShortSchema.extend({
+    linkedExternalId: z.string().nullable(),
+    linkedExternalName: z.string().nullable(),
+});

package/schemas/integration/moysklad/moysklad-measure-unit-link-mapping.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+
+export const MoyskladMeasureUnitLinkMappingSchema = z.object({
+    externalId: z.string().min(1),
+    action: z.literal('LINK'),
+    measureUnitUUID: z.string().uuid(),
+});

package/schemas/integration/moysklad/moysklad-measure-unit-mapping.schema.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { MoyskladMeasureUnitLinkMappingSchema } from './moysklad-measure-unit-link-mapping.schema';
+import { MoyskladMeasureUnitCreateMappingSchema } from './moysklad-measure-unit-create-mapping.schema';
+
+export const MoyskladMeasureUnitMappingSchema = z.discriminatedUnion('action', [
+    MoyskladMeasureUnitLinkMappingSchema,
+    MoyskladMeasureUnitCreateMappingSchema,
+]);

package/schemas/integration/moysklad/moysklad-scanned-item.schema.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import { MoyskladImportItemStatusEnum, SalesUnitEnum } from '../../../enum';
+import { MoneySchema } from '../../money.schema';
+
+export const MoyskladScannedItemSchema = 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(),
+    measureUnitExternalId: z.string().nullable(),
+    measureUnitUUID: z.string().uuid(),
+    uomCode: z.string().nullable().optional(),
+    uomName: z.string().nullable().optional(),
+    salesUnit: z.nativeEnum(SalesUnitEnum).nullable(),
+    status: z.nativeEnum(MoyskladImportItemStatusEnum),
+    internalUUID: z.string().nullable(),
+    resolvedCategoryUUID: z.string().nullable(),
+    resolvedCategoryName: z.string().nullable(),
+    resolvedImageUUID: z.string().nullable(),
+});

package/schemas/integration/moysklad/moysklad-scanned-measure-unit.schema.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { MeasureUnitMatchSourceEnum } from '../../../enum/measure-unit-match-source.enum';
+
+export const MoyskladScannedMeasureUnitSchema = z.object({
+    externalId: z.string(),
+    externalName: z.string(),
+    okeiCode: z.string().nullable(),
+    itemCount: z.number(),
+    measureUnitUUID: z.string(),
+    matchedBy: z.nativeEnum(MeasureUnitMatchSourceEnum),
+});

package/schemas/integration/moysklad/scan-moysklad-import-response-data-categories.schema.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+import { MoyskladCategoryMatchSchema } from './moysklad-category-match.schema';
+
+export const ScanMoyskladImportResponseDataCategoriesSchema = z.object({
+    matched: z.array(MoyskladCategoryMatchSchema),
+});

package/schemas/integration/moysklad/scan-moysklad-import-response-data-summary.schema.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+
+export const ScanMoyskladImportResponseDataSummarySchema = z.object({
+    withCategory: z.number(),
+    withoutCategory: z.number(),
+    withColor: z.number(),
+    withCountry: z.number(),
+    withGrower: z.number(),
+    withSize: z.number(),
+    withImage: z.number(),
+});

package/schemas/integration/moysklad/scan-moysklad-import-response-data.schema.ts

@@ -0,0 +1,22 @@
+import { MoyskladMeasureUnitDictionaryItemSchema } from './moysklad-measure-unit-dictionary-item.schema';
+import { z } from 'zod';
+import { MoyskladScannedMeasureUnitSchema } from './moysklad-scanned-measure-unit.schema';
+import { MoyskladScannedItemSchema } from './moysklad-scanned-item.schema';
+import { ScanMoyskladImportResponseDataCategoriesSchema } from './scan-moysklad-import-response-data-categories.schema';
+import { ScanMoyskladImportResponseDataSummarySchema } from './scan-moysklad-import-response-data-summary.schema';
+
+export const ScanMoyskladImportResponseDataSchema = z.object({
+    measureUnitDictionary: z.array(MoyskladMeasureUnitDictionaryItemSchema).optional(),
+    measureUnits: z.array(MoyskladScannedMeasureUnitSchema),
+    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: ScanMoyskladImportResponseDataCategoriesSchema,
+    summary: ScanMoyskladImportResponseDataSummarySchema,
+    items: z.array(MoyskladScannedItemSchema),
+});

package/schemas/integration/moysklad/scan-moysklad-import-response.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { ScanMoyskladImportResponseDataSchema } from './scan-moysklad-import-response-data.schema';
+
+export const ScanMoyskladImportResponseSchema = z.object({
+    message: z.string().optional(),
+    data: ScanMoyskladImportResponseDataSchema,
+});

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

@@ -11,3 +11,5 @@ export * from './one-c-stock-conflict-preview.schema';
 export * from './one-c-stock-conflict-resolution.schema';
 export * from './resolve-one-c-stock-conflict-request.schema';
 export * from './resolve-one-c-stock-conflict-response.schema';
+export * from './update-one-c-settings-request.schema';
+export * from './update-one-c-settings-response.schema';