@floristcloud/api-lib 1.2.19 → 1.2.20

package/build/commands/integration/index.js

@@ -16,3 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./telegram"), exports);
 __exportStar(require("./telegram-staff"), exports);
+__exportStar(require("./moysklad"), exports);

package/build/commands/integration/moysklad/connect-moysklad.command.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectMoyskladContractCommand = void 0;
+const zod_1 = require("zod");
+const ConnectMoyskladRequestSchema = zod_1.z.object({
+    token: zod_1.z.string().min(20).max(200),
+});
+const ConnectMoyskladResponseSchema = zod_1.z.object({
+    message: zod_1.z.string().optional(),
+    data: zod_1.z.object({
+        tokenLastFour: zod_1.z.string().length(4),
+        accountId: zod_1.z.string().nullable(),
+    }),
+});
+var ConnectMoyskladContractCommand;
+(function (ConnectMoyskladContractCommand) {
+    ConnectMoyskladContractCommand.RequestSchema = ConnectMoyskladRequestSchema;
+    ConnectMoyskladContractCommand.ResponseSchema = ConnectMoyskladResponseSchema;
+})(ConnectMoyskladContractCommand || (exports.ConnectMoyskladContractCommand = ConnectMoyskladContractCommand = {}));

package/build/commands/integration/moysklad/disconnect-moysklad.command.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DisconnectMoyskladContractCommand = void 0;
+const zod_1 = require("zod");
+const DisconnectMoyskladResponseSchema = zod_1.z.object({
+    message: zod_1.z.string().optional(),
+    data: zod_1.z.object({
+        success: zod_1.z.literal(true),
+    }),
+});
+var DisconnectMoyskladContractCommand;
+(function (DisconnectMoyskladContractCommand) {
+    DisconnectMoyskladContractCommand.ResponseSchema = DisconnectMoyskladResponseSchema;
+})(DisconnectMoyskladContractCommand || (exports.DisconnectMoyskladContractCommand = DisconnectMoyskladContractCommand = {}));

package/build/commands/integration/moysklad/enable-moysklad.command.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnableMoyskladContractCommand = void 0;
+const zod_1 = require("zod");
+const EnableMoyskladRequestSchema = zod_1.z.object({
+    defaultOrgId: zod_1.z.string().min(1),
+    defaultStoreId: zod_1.z.string().min(1),
+});
+const EnableMoyskladResponseSchema = zod_1.z.object({
+    message: zod_1.z.string().optional(),
+    data: zod_1.z.object({
+        isEnabled: zod_1.z.literal(true),
+    }),
+});
+var EnableMoyskladContractCommand;
+(function (EnableMoyskladContractCommand) {
+    EnableMoyskladContractCommand.RequestSchema = EnableMoyskladRequestSchema;
+    EnableMoyskladContractCommand.ResponseSchema = EnableMoyskladResponseSchema;
+})(EnableMoyskladContractCommand || (exports.EnableMoyskladContractCommand = EnableMoyskladContractCommand = {}));

package/build/commands/integration/moysklad/execute-moysklad-clients-import.command.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExecuteMoyskladClientsImportContractCommand = void 0;
+const zod_1 = require("zod");
+const error_message_schema_1 = require("../../../schemas/error-message.schema");
+const scan_moysklad_clients_import_query_1 = require("./scan-moysklad-clients-import.query");
+const ExecutableClientItemSchema = scan_moysklad_clients_import_query_1.ScanMoyskladClientsImportContractQuery.ItemSchema.extend({
+    bindToExistingClientUUID: zod_1.z.string().nullable().default(null),
+});
+const ExecuteMoyskladClientsImportRequestSchema = zod_1.z.object({
+    items: zod_1.z.array(ExecutableClientItemSchema),
+    missingExternalIds: zod_1.z.array(zod_1.z.string()).default([]),
+    orphanedExternalIds: zod_1.z.array(zod_1.z.string()).default([]),
+});
+const ImportWarningSchema = zod_1.z.object({
+    externalSourceId: zod_1.z.string(),
+    warning: error_message_schema_1.ErrorMessageSchema,
+});
+const ExecuteMoyskladClientsImportResponseSchema = zod_1.z.object({
+    message: zod_1.z.string().optional(),
+    data: zod_1.z.object({
+        created: zod_1.z.number(),
+        updated: zod_1.z.number(),
+        bound: zod_1.z.number(),
+        archived: zod_1.z.number(),
+        orphansCleaned: zod_1.z.number(),
+        warnings: zod_1.z.array(ImportWarningSchema).default([]),
+    }),
+});
+var ExecuteMoyskladClientsImportContractCommand;
+(function (ExecuteMoyskladClientsImportContractCommand) {
+    ExecuteMoyskladClientsImportContractCommand.ItemSchema = ExecutableClientItemSchema;
+    ExecuteMoyskladClientsImportContractCommand.RequestSchema = ExecuteMoyskladClientsImportRequestSchema;
+    ExecuteMoyskladClientsImportContractCommand.ResponseSchema = ExecuteMoyskladClientsImportResponseSchema;
+    ExecuteMoyskladClientsImportContractCommand.WarningSchema = ImportWarningSchema;
+})(ExecuteMoyskladClientsImportContractCommand || (exports.ExecuteMoyskladClientsImportContractCommand = ExecuteMoyskladClientsImportContractCommand = {}));

package/build/commands/integration/moysklad/execute-moysklad-import.command.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExecuteMoyskladImportContractCommand = void 0;
+const zod_1 = require("zod");
+const enum_1 = require("../../../enum");
+const ExecutableItemSchema = zod_1.z.object({
+    externalSourceId: zod_1.z.string(),
+    externalHref: zod_1.z.string(),
+    name: zod_1.z.string(),
+    article: zod_1.z.string().nullable(),
+    barcode: zod_1.z.string().nullable(),
+    size: zod_1.z.string().nullable(),
+    color: zod_1.z.string().nullable(),
+    country: zod_1.z.string().nullable(),
+    grower: zod_1.z.string().nullable(),
+    price: zod_1.z.number(),
+    costPrice: zod_1.z.number(),
+    balance: zod_1.z.number(),
+    vat: zod_1.z.number().nullable(),
+    salesUnit: zod_1.z.nativeEnum(enum_1.SalesUnitEnum),
+    status: zod_1.z.enum(['new', 'known']),
+    internalUUID: zod_1.z.string().nullable(),
+    resolvedCategoryUUID: zod_1.z.string().nullable(),
+});
+const ExecuteMoyskladImportRequestSchema = zod_1.z.object({
+    items: zod_1.z.array(ExecutableItemSchema),
+    missingExternalIds: zod_1.z.array(zod_1.z.string()).default([]),
+    orphanedExternalIds: zod_1.z.array(zod_1.z.string()).default([]),
+});
+const ExecuteMoyskladImportResponseSchema = zod_1.z.object({
+    message: zod_1.z.string().optional(),
+    data: zod_1.z.object({
+        created: zod_1.z.number(),
+        updated: zod_1.z.number(),
+        archived: zod_1.z.number(),
+        orphansCleaned: zod_1.z.number(),
+        consignmentUUID: zod_1.z.string(),
+    }),
+});
+var ExecuteMoyskladImportContractCommand;
+(function (ExecuteMoyskladImportContractCommand) {
+    ExecuteMoyskladImportContractCommand.RequestSchema = ExecuteMoyskladImportRequestSchema;
+    ExecuteMoyskladImportContractCommand.ResponseSchema = ExecuteMoyskladImportResponseSchema;
+})(ExecuteMoyskladImportContractCommand || (exports.ExecuteMoyskladImportContractCommand = ExecuteMoyskladImportContractCommand = {}));

package/build/commands/integration/moysklad/get-moysklad-status.query.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetMoyskladStatusContractQuery = void 0;
+const zod_1 = require("zod");
+const GetMoyskladStatusResponseSchema = zod_1.z.object({
+    message: zod_1.z.string().optional(),
+    data: zod_1.z.object({
+        isConnected: zod_1.z.boolean(),
+        isEnabled: zod_1.z.boolean(),
+        tokenLastFour: zod_1.z.string().length(4).nullable(),
+        accountId: zod_1.z.string().nullable(),
+        defaultOrgId: zod_1.z.string().nullable(),
+        defaultStoreId: zod_1.z.string().nullable(),
+        lastSyncAt: zod_1.z.string().datetime().nullable(),
+    }),
+});
+var GetMoyskladStatusContractQuery;
+(function (GetMoyskladStatusContractQuery) {
+    GetMoyskladStatusContractQuery.ResponseSchema = GetMoyskladStatusResponseSchema;
+})(GetMoyskladStatusContractQuery || (exports.GetMoyskladStatusContractQuery = GetMoyskladStatusContractQuery = {}));

package/build/commands/integration/moysklad/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./connect-moysklad.command"), exports);
+__exportStar(require("./enable-moysklad.command"), exports);
+__exportStar(require("./disconnect-moysklad.command"), exports);
+__exportStar(require("./get-moysklad-status.query"), exports);
+__exportStar(require("./list-moysklad-catalogs.query"), exports);
+__exportStar(require("./preview-moysklad-products.query"), exports);
+__exportStar(require("./scan-moysklad-import.query"), exports);
+__exportStar(require("./execute-moysklad-import.command"), exports);
+__exportStar(require("./scan-moysklad-clients-import.query"), exports);
+__exportStar(require("./execute-moysklad-clients-import.command"), exports);

package/build/commands/integration/moysklad/list-moysklad-catalogs.query.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListMoyskladCatalogsContractQuery = void 0;
+const zod_1 = require("zod");
+const MoyskladCatalogItemSchema = zod_1.z.object({
+    id: zod_1.z.string().min(1),
+    name: zod_1.z.string(),
+});
+const ListMoyskladCatalogsResponseSchema = zod_1.z.object({
+    message: zod_1.z.string().optional(),
+    data: zod_1.z.object({
+        organizations: zod_1.z.array(MoyskladCatalogItemSchema),
+        stores: zod_1.z.array(MoyskladCatalogItemSchema),
+    }),
+});
+var ListMoyskladCatalogsContractQuery;
+(function (ListMoyskladCatalogsContractQuery) {
+    ListMoyskladCatalogsContractQuery.ResponseSchema = ListMoyskladCatalogsResponseSchema;
+})(ListMoyskladCatalogsContractQuery || (exports.ListMoyskladCatalogsContractQuery = ListMoyskladCatalogsContractQuery = {}));

package/build/commands/integration/moysklad/preview-moysklad-products.query.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreviewMoyskladProductsContractQuery = void 0;
+const zod_1 = require("zod");
+const PreviewMoyskladProductsRequestSchema = zod_1.z.object({
+    limit: zod_1.z.coerce.number().int().min(1).max(100).default(20),
+});
+const MappedProductPreviewSchema = zod_1.z.object({
+    externalSourceId: zod_1.z.string(),
+    externalHref: zod_1.z.string(),
+    name: zod_1.z.string(),
+    article: zod_1.z.string().nullable(),
+    size: zod_1.z.string().nullable(),
+    color: zod_1.z.string().nullable(),
+    country: zod_1.z.string().nullable(),
+    grower: zod_1.z.string().nullable(),
+    price: zod_1.z.number(),
+    costPrice: zod_1.z.number(),
+    balance: zod_1.z.number(),
+    categoryName: zod_1.z.string().nullable(),
+});
+const PreviewMoyskladProductsResponseSchema = zod_1.z.object({
+    message: zod_1.z.string().optional(),
+    data: zod_1.z.object({
+        rawProductCount: zod_1.z.number(),
+        expandedItemCount: zod_1.z.number(),
+        summary: zod_1.z.object({
+            withCategory: zod_1.z.number(),
+            withoutCategory: zod_1.z.number(),
+            withColor: zod_1.z.number(),
+            withCountry: zod_1.z.number(),
+            withGrower: zod_1.z.number(),
+            withSize: zod_1.z.number(),
+        }),
+        items: zod_1.z.array(MappedProductPreviewSchema),
+    }),
+});
+var PreviewMoyskladProductsContractQuery;
+(function (PreviewMoyskladProductsContractQuery) {
+    PreviewMoyskladProductsContractQuery.RequestSchema = PreviewMoyskladProductsRequestSchema;
+    PreviewMoyskladProductsContractQuery.ResponseSchema = PreviewMoyskladProductsResponseSchema;
+})(PreviewMoyskladProductsContractQuery || (exports.PreviewMoyskladProductsContractQuery = PreviewMoyskladProductsContractQuery = {}));

package/build/commands/integration/moysklad/scan-moysklad-clients-import.query.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScanMoyskladClientsImportContractQuery = void 0;
+const zod_1 = require("zod");
+const client_legal_type_enum_1 = require("../../../enum/client-legal-type.enum");
+const client_type_enum_1 = require("../../../enum/client-type.enum");
+const ScannedClientItemSchema = zod_1.z.object({
+    externalSourceId: zod_1.z.string(),
+    externalHref: zod_1.z.string(),
+    name: zod_1.z.string(),
+    contactName: zod_1.z.string().nullable(),
+    phone: zod_1.z.string().nullable(),
+    rawPhone: zod_1.z.string().nullable(),
+    email: zod_1.z.string().nullable(),
+    address: zod_1.z.string().nullable(),
+    code: zod_1.z.string().nullable(),
+    comment: zod_1.z.string().nullable(),
+    clientType: zod_1.z.nativeEnum(client_type_enum_1.ClientTypeEnum),
+    legalType: zod_1.z.nativeEnum(client_legal_type_enum_1.ClientLegalTypeEnum).nullable(),
+    archived: zod_1.z.boolean(),
+    firstName: zod_1.z.string().nullable(),
+    lastName: zod_1.z.string().nullable(),
+    middleName: zod_1.z.string().nullable(),
+    legalTitle: zod_1.z.string().nullable(),
+    inn: zod_1.z.string().nullable(),
+    kpp: zod_1.z.string().nullable(),
+    ogrn: zod_1.z.string().nullable(),
+    ogrnip: zod_1.z.string().nullable(),
+    legalAddress: zod_1.z.string().nullable(),
+    bankName: zod_1.z.string().nullable(),
+    bankAccountNumber: zod_1.z.string().nullable(),
+    bankBic: zod_1.z.string().nullable(),
+    isPhoneNormalized: zod_1.z.boolean(),
+    status: zod_1.z.enum(['new', 'known']),
+    internalUUID: zod_1.z.string().nullable(),
+    suggestedMatch: zod_1.z
+        .object({
+        clientUUID: zod_1.z.string(),
+        clientDisplayName: zod_1.z.string(),
+        matchedBy: zod_1.z.enum(['INN', 'PHONE']),
+    })
+        .nullable(),
+});
+const ScanMoyskladClientsImportResponseSchema = zod_1.z.object({
+    message: zod_1.z.string().optional(),
+    data: zod_1.z.object({
+        rawCount: zod_1.z.number(),
+        knownCount: zod_1.z.number(),
+        newCount: zod_1.z.number(),
+        matchedCount: zod_1.z.number(),
+        archivedInMSCount: zod_1.z.number(),
+        missingExternalIds: zod_1.z.array(zod_1.z.string()),
+        orphanedExternalIds: zod_1.z.array(zod_1.z.string()),
+        items: zod_1.z.array(ScannedClientItemSchema),
+    }),
+});
+var ScanMoyskladClientsImportContractQuery;
+(function (ScanMoyskladClientsImportContractQuery) {
+    ScanMoyskladClientsImportContractQuery.ItemSchema = ScannedClientItemSchema;
+    ScanMoyskladClientsImportContractQuery.ResponseSchema = ScanMoyskladClientsImportResponseSchema;
+})(ScanMoyskladClientsImportContractQuery || (exports.ScanMoyskladClientsImportContractQuery = ScanMoyskladClientsImportContractQuery = {}));

package/build/commands/integration/moysklad/scan-moysklad-import.query.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScanMoyskladImportContractQuery = void 0;
+const zod_1 = require("zod");
+const enum_1 = require("../../../enum");
+const ScannedItemSchema = zod_1.z.object({
+    externalSourceId: zod_1.z.string(),
+    externalHref: zod_1.z.string(),
+    name: zod_1.z.string(),
+    article: zod_1.z.string().nullable(),
+    barcode: zod_1.z.string().nullable(),
+    size: zod_1.z.string().nullable(),
+    color: zod_1.z.string().nullable(),
+    country: zod_1.z.string().nullable(),
+    grower: zod_1.z.string().nullable(),
+    price: zod_1.z.number(),
+    costPrice: zod_1.z.number(),
+    balance: zod_1.z.number(),
+    categoryName: zod_1.z.string().nullable(),
+    vat: zod_1.z.number().nullable(),
+    salesUnit: zod_1.z.nativeEnum(enum_1.SalesUnitEnum),
+    status: zod_1.z.enum(['new', 'known']),
+    internalUUID: zod_1.z.string().nullable(),
+    resolvedCategoryUUID: zod_1.z.string().nullable(),
+    resolvedCategoryName: zod_1.z.string().nullable(),
+});
+const CategoryMatchSchema = zod_1.z.object({
+    fcCategoryUUID: zod_1.z.string(),
+    fcCategoryName: zod_1.z.string(),
+    itemsCount: zod_1.z.number(),
+});
+const ScanMoyskladImportResponseSchema = zod_1.z.object({
+    message: zod_1.z.string().optional(),
+    data: zod_1.z.object({
+        rawProductCount: zod_1.z.number(),
+        expandedItemCount: zod_1.z.number(),
+        knownItems: zod_1.z.number(),
+        newItems: zod_1.z.number(),
+        missingItemsCount: zod_1.z.number(),
+        missingExternalIds: zod_1.z.array(zod_1.z.string()),
+        orphanedItemsCount: zod_1.z.number(),
+        orphanedExternalIds: zod_1.z.array(zod_1.z.string()),
+        categories: zod_1.z.object({
+            matched: zod_1.z.array(CategoryMatchSchema),
+        }),
+        summary: zod_1.z.object({
+            withCategory: zod_1.z.number(),
+            withoutCategory: zod_1.z.number(),
+            withColor: zod_1.z.number(),
+            withCountry: zod_1.z.number(),
+            withGrower: zod_1.z.number(),
+            withSize: zod_1.z.number(),
+        }),
+        items: zod_1.z.array(ScannedItemSchema),
+    }),
+});
+var ScanMoyskladImportContractQuery;
+(function (ScanMoyskladImportContractQuery) {
+    ScanMoyskladImportContractQuery.ResponseSchema = ScanMoyskladImportResponseSchema;
+})(ScanMoyskladImportContractQuery || (exports.ScanMoyskladImportContractQuery = ScanMoyskladImportContractQuery = {}));

package/build/constant/error.js

@@ -978,4 +978,18 @@ exports.ERRORS = {
     PUBLIC_ACCOUNT_DELETION_INVALID_CODE: { code: 'ADR009', message: 'Invalid or expired verification code', httpCode: 400 },
     PUBLIC_ACCOUNT_DELETION_INVALID_TOKEN: { code: 'ADR010', message: 'Invalid or expired verification token', httpCode: 400 },
     PUBLIC_ACCOUNT_DELETION_NO_TENANTS_SELECTED: { code: 'ADR011', message: 'No valid tenants selected for deletion', httpCode: 400 },
+    // MOYSKLAD INTEGRATION
+    MOYSKLAD_INVALID_TOKEN: { code: 'MS001', message: 'MoySklad token is invalid or has insufficient permissions', httpCode: 400 },
+    MOYSKLAD_CONNECT_FAILED: { code: 'MS002', message: 'Failed to connect MoySklad integration', httpCode: 500 },
+    MOYSKLAD_NOT_CONNECTED: { code: 'MS003', message: 'MoySklad integration is not connected for this company', httpCode: 404 },
+    MOYSKLAD_API_ERROR: { code: 'MS004', message: 'MoySklad API request failed', httpCode: 502 },
+    MOYSKLAD_DISCONNECT_FAILED: { code: 'MS005', message: 'Failed to disconnect MoySklad integration', httpCode: 500 },
+    MOYSKLAD_SETTINGS_INVALID: { code: 'MS006', message: 'Provided organization or store does not belong to the connected MoySklad account', httpCode: 400 },
+    INTEGRATION_ENC_KEY_NOT_SET: { code: 'MS007', message: 'Integration encryption key is not configured on the server', httpCode: 500 },
+    MOYSKLAD_IMPORT_IN_PROGRESS: { code: 'MS008', message: 'MoySklad import is already in progress for this company', httpCode: 409 },
+    MOYSKLAD_CLIENTS_IMPORT_IN_PROGRESS: {
+        code: 'MS009',
+        message: 'MoySklad clients import is already in progress for this company',
+        httpCode: 409,
+    },
 };

package/build/enum/external-entity-type.enum.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExternalEntityTypeEnum = void 0;
+var ExternalEntityTypeEnum;
+(function (ExternalEntityTypeEnum) {
+    ExternalEntityTypeEnum["PRODUCT"] = "PRODUCT";
+    ExternalEntityTypeEnum["CATEGORY"] = "CATEGORY";
+    ExternalEntityTypeEnum["CLIENT"] = "CLIENT";
+    ExternalEntityTypeEnum["ORDER"] = "ORDER";
+})(ExternalEntityTypeEnum || (exports.ExternalEntityTypeEnum = ExternalEntityTypeEnum = {}));

package/build/enum/index.js

@@ -15,6 +15,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./consignment-status.enum"), exports);
+__exportStar(require("./integration-provider.enum"), exports);
+__exportStar(require("./external-entity-type.enum"), exports);
 __exportStar(require("./order-type.enum"), exports);
 __exportStar(require("./order-status.enum"), exports);
 __exportStar(require("./order-restricted-status-list"), exports);

package/build/enum/integration-provider.enum.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntegrationProviderEnum = void 0;
+var IntegrationProviderEnum;
+(function (IntegrationProviderEnum) {
+    IntegrationProviderEnum["MOYSKLAD"] = "MOYSKLAD";
+})(IntegrationProviderEnum || (exports.IntegrationProviderEnum = IntegrationProviderEnum = {}));

package/commands/integration/index.ts

@@ -1,3 +1,4 @@
 export * from './telegram';
 export * from './telegram-staff';
+export * from './moysklad';
 

package/commands/integration/moysklad/connect-moysklad.command.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+
+const ConnectMoyskladRequestSchema = z.object({
+    token: z.string().min(20).max(200),
+});
+
+const ConnectMoyskladResponseSchema = z.object({
+    message: z.string().optional(),
+    data: z.object({
+        tokenLastFour: z.string().length(4),
+        accountId: z.string().nullable(),
+    }),
+});
+
+export namespace ConnectMoyskladContractCommand {
+    export const RequestSchema = ConnectMoyskladRequestSchema;
+    export type Request = z.infer<typeof RequestSchema>;
+    export const ResponseSchema = ConnectMoyskladResponseSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/integration/moysklad/disconnect-moysklad.command.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+
+const DisconnectMoyskladResponseSchema = z.object({
+    message: z.string().optional(),
+    data: z.object({
+        success: z.literal(true),
+    }),
+});
+
+export namespace DisconnectMoyskladContractCommand {
+    export const ResponseSchema = DisconnectMoyskladResponseSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/integration/moysklad/enable-moysklad.command.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+
+const EnableMoyskladRequestSchema = z.object({
+    defaultOrgId: z.string().min(1),
+    defaultStoreId: z.string().min(1),
+});
+
+const EnableMoyskladResponseSchema = z.object({
+    message: z.string().optional(),
+    data: z.object({
+        isEnabled: z.literal(true),
+    }),
+});
+
+export namespace EnableMoyskladContractCommand {
+    export const RequestSchema = EnableMoyskladRequestSchema;
+    export type Request = z.infer<typeof RequestSchema>;
+    export const ResponseSchema = EnableMoyskladResponseSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+}

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

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+import { ErrorMessageSchema } from '../../../schemas/error-message.schema';
+import { ScanMoyskladClientsImportContractQuery } from './scan-moysklad-clients-import.query';
+
+const ExecutableClientItemSchema = ScanMoyskladClientsImportContractQuery.ItemSchema.extend({
+    bindToExistingClientUUID: z.string().nullable().default(null),
+});
+
+const ExecuteMoyskladClientsImportRequestSchema = z.object({
+    items: z.array(ExecutableClientItemSchema),
+    missingExternalIds: z.array(z.string()).default([]),
+    orphanedExternalIds: z.array(z.string()).default([]),
+});
+
+const ImportWarningSchema = z.object({
+    externalSourceId: z.string(),
+    warning: ErrorMessageSchema,
+});
+
+const ExecuteMoyskladClientsImportResponseSchema = z.object({
+    message: z.string().optional(),
+    data: z.object({
+        created: z.number(),
+        updated: z.number(),
+        bound: z.number(),
+        archived: z.number(),
+        orphansCleaned: z.number(),
+        warnings: z.array(ImportWarningSchema).default([]),
+    }),
+});
+
+export namespace ExecuteMoyskladClientsImportContractCommand {
+    export const ItemSchema = ExecutableClientItemSchema;
+    export type Item = z.infer<typeof ExecutableClientItemSchema>;
+    export const RequestSchema = ExecuteMoyskladClientsImportRequestSchema;
+    export type Request = z.infer<typeof RequestSchema>;
+    export const ResponseSchema = ExecuteMoyskladClientsImportResponseSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+    export const WarningSchema = ImportWarningSchema;
+    export type Warning = z.infer<typeof WarningSchema>;
+}

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

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+import { SalesUnitEnum } from '../../../enum';
+
+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: z.number(),
+    costPrice: z.number(),
+    balance: z.number(),
+    vat: z.number().nullable(),
+    salesUnit: z.nativeEnum(SalesUnitEnum),
+    status: z.enum(['new', 'known']),
+    internalUUID: z.string().nullable(),
+    resolvedCategoryUUID: 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(),
+    }),
+});
+
+export namespace ExecuteMoyskladImportContractCommand {
+    export const RequestSchema = ExecuteMoyskladImportRequestSchema;
+    export type Request = z.infer<typeof RequestSchema>;
+    export const ResponseSchema = ExecuteMoyskladImportResponseSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/integration/moysklad/get-moysklad-status.query.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+
+const GetMoyskladStatusResponseSchema = z.object({
+    message: z.string().optional(),
+    data: z.object({
+        isConnected: z.boolean(),
+        isEnabled: z.boolean(),
+        tokenLastFour: z.string().length(4).nullable(),
+        accountId: z.string().nullable(),
+        defaultOrgId: z.string().nullable(),
+        defaultStoreId: z.string().nullable(),
+        lastSyncAt: z.string().datetime().nullable(),
+    }),
+});
+
+export namespace GetMoyskladStatusContractQuery {
+    export const ResponseSchema = GetMoyskladStatusResponseSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/integration/moysklad/index.ts

@@ -0,0 +1,10 @@
+export * from './connect-moysklad.command';
+export * from './enable-moysklad.command';
+export * from './disconnect-moysklad.command';
+export * from './get-moysklad-status.query';
+export * from './list-moysklad-catalogs.query';
+export * from './preview-moysklad-products.query';
+export * from './scan-moysklad-import.query';
+export * from './execute-moysklad-import.command';
+export * from './scan-moysklad-clients-import.query';
+export * from './execute-moysklad-clients-import.command';

package/commands/integration/moysklad/list-moysklad-catalogs.query.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+
+const MoyskladCatalogItemSchema = z.object({
+    id: z.string().min(1),
+    name: z.string(),
+});
+
+const ListMoyskladCatalogsResponseSchema = z.object({
+    message: z.string().optional(),
+    data: z.object({
+        organizations: z.array(MoyskladCatalogItemSchema),
+        stores: z.array(MoyskladCatalogItemSchema),
+    }),
+});
+
+export namespace ListMoyskladCatalogsContractQuery {
+    export const ResponseSchema = ListMoyskladCatalogsResponseSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/integration/moysklad/preview-moysklad-products.query.ts

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+
+const PreviewMoyskladProductsRequestSchema = z.object({
+    limit: z.coerce.number().int().min(1).max(100).default(20),
+});
+
+const MappedProductPreviewSchema = z.object({
+    externalSourceId: z.string(),
+    externalHref: z.string(),
+    name: z.string(),
+    article: z.string().nullable(),
+    size: z.string().nullable(),
+    color: z.string().nullable(),
+    country: z.string().nullable(),
+    grower: z.string().nullable(),
+    price: z.number(),
+    costPrice: z.number(),
+    balance: z.number(),
+    categoryName: z.string().nullable(),
+});
+
+const PreviewMoyskladProductsResponseSchema = z.object({
+    message: z.string().optional(),
+    data: z.object({
+        rawProductCount: z.number(),
+        expandedItemCount: z.number(),
+        summary: z.object({
+            withCategory: z.number(),
+            withoutCategory: z.number(),
+            withColor: z.number(),
+            withCountry: z.number(),
+            withGrower: z.number(),
+            withSize: z.number(),
+        }),
+        items: z.array(MappedProductPreviewSchema),
+    }),
+});
+
+export namespace PreviewMoyskladProductsContractQuery {
+    export const RequestSchema = PreviewMoyskladProductsRequestSchema;
+    export type Request = z.infer<typeof RequestSchema>;
+    export const ResponseSchema = PreviewMoyskladProductsResponseSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+}

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

@@ -0,0 +1,68 @@
+import { z } from 'zod';
+import { ClientLegalTypeEnum } from '../../../enum/client-legal-type.enum';
+import { ClientTypeEnum } from '../../../enum/client-type.enum';
+
+const ScannedClientItemSchema = z.object({
+    externalSourceId: z.string(),
+    externalHref: z.string(),
+
+    name: z.string(),
+    contactName: z.string().nullable(),
+    phone: z.string().nullable(),
+    rawPhone: z.string().nullable(),
+    email: z.string().nullable(),
+    address: z.string().nullable(),
+    code: z.string().nullable(),
+    comment: z.string().nullable(),
+    clientType: z.nativeEnum(ClientTypeEnum),
+    legalType: z.nativeEnum(ClientLegalTypeEnum).nullable(),
+    archived: z.boolean(),
+
+    firstName: z.string().nullable(),
+    lastName: z.string().nullable(),
+    middleName: z.string().nullable(),
+
+    legalTitle: z.string().nullable(),
+    inn: z.string().nullable(),
+    kpp: z.string().nullable(),
+    ogrn: z.string().nullable(),
+    ogrnip: z.string().nullable(),
+    legalAddress: z.string().nullable(),
+
+    bankName: z.string().nullable(),
+    bankAccountNumber: z.string().nullable(),
+    bankBic: z.string().nullable(),
+
+    isPhoneNormalized: z.boolean(),
+
+    status: z.enum(['new', 'known']),
+    internalUUID: z.string().nullable(),
+    suggestedMatch: z
+        .object({
+            clientUUID: z.string(),
+            clientDisplayName: z.string(),
+            matchedBy: z.enum(['INN', 'PHONE']),
+        })
+        .nullable(),
+});
+
+const ScanMoyskladClientsImportResponseSchema = z.object({
+    message: z.string().optional(),
+    data: z.object({
+        rawCount: z.number(),
+        knownCount: z.number(),
+        newCount: z.number(),
+        matchedCount: z.number(),
+        archivedInMSCount: z.number(),
+        missingExternalIds: z.array(z.string()),
+        orphanedExternalIds: z.array(z.string()),
+        items: z.array(ScannedClientItemSchema),
+    }),
+});
+
+export namespace ScanMoyskladClientsImportContractQuery {
+    export const ItemSchema = ScannedClientItemSchema;
+    export type Item = z.infer<typeof ScannedClientItemSchema>;
+    export const ResponseSchema = ScanMoyskladClientsImportResponseSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+}

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

@@ -0,0 +1,61 @@
+import { z } from 'zod';
+import { SalesUnitEnum } from '../../../enum';
+
+const ScannedItemSchema = 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: z.number(),
+    costPrice: z.number(),
+    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(),
+});
+
+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(),
+        }),
+        items: z.array(ScannedItemSchema),
+    }),
+});
+
+export namespace ScanMoyskladImportContractQuery {
+    export const ResponseSchema = ScanMoyskladImportResponseSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/constant/error.ts

@@ -1037,4 +1037,19 @@ export const ERRORS = {
     PUBLIC_ACCOUNT_DELETION_INVALID_CODE: { code: 'ADR009', message: 'Invalid or expired verification code', httpCode: 400 },
     PUBLIC_ACCOUNT_DELETION_INVALID_TOKEN: { code: 'ADR010', message: 'Invalid or expired verification token', httpCode: 400 },
     PUBLIC_ACCOUNT_DELETION_NO_TENANTS_SELECTED: { code: 'ADR011', message: 'No valid tenants selected for deletion', httpCode: 400 },
+
+    // MOYSKLAD INTEGRATION
+    MOYSKLAD_INVALID_TOKEN: { code: 'MS001', message: 'MoySklad token is invalid or has insufficient permissions', httpCode: 400 },
+    MOYSKLAD_CONNECT_FAILED: { code: 'MS002', message: 'Failed to connect MoySklad integration', httpCode: 500 },
+    MOYSKLAD_NOT_CONNECTED: { code: 'MS003', message: 'MoySklad integration is not connected for this company', httpCode: 404 },
+    MOYSKLAD_API_ERROR: { code: 'MS004', message: 'MoySklad API request failed', httpCode: 502 },
+    MOYSKLAD_DISCONNECT_FAILED: { code: 'MS005', message: 'Failed to disconnect MoySklad integration', httpCode: 500 },
+    MOYSKLAD_SETTINGS_INVALID: { code: 'MS006', message: 'Provided organization or store does not belong to the connected MoySklad account', httpCode: 400 },
+    INTEGRATION_ENC_KEY_NOT_SET: { code: 'MS007', message: 'Integration encryption key is not configured on the server', httpCode: 500 },
+    MOYSKLAD_IMPORT_IN_PROGRESS: { code: 'MS008', message: 'MoySklad import is already in progress for this company', httpCode: 409 },
+    MOYSKLAD_CLIENTS_IMPORT_IN_PROGRESS: {
+        code: 'MS009',
+        message: 'MoySklad clients import is already in progress for this company',
+        httpCode: 409,
+    },
 } as const;

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

@@ -0,0 +1,6 @@
+export enum ExternalEntityTypeEnum {
+    PRODUCT = 'PRODUCT',
+    CATEGORY = 'CATEGORY',
+    CLIENT = 'CLIENT',
+    ORDER = 'ORDER',
+}

package/enum/index.ts

@@ -1,4 +1,6 @@
 export * from './consignment-status.enum';
+export * from './integration-provider.enum';
+export * from './external-entity-type.enum';
 export * from './order-type.enum';
 export * from './order-status.enum';
 export * from './order-restricted-status-list';

package/enum/integration-provider.enum.ts

@@ -0,0 +1,3 @@
+export enum IntegrationProviderEnum {
+    MOYSKLAD = 'MOYSKLAD',
+}

package/package.json

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