n8n-nodes-pragma-bitrix24 1.0.0

package/dist/nodes/Bitrix24/Bitrix24.node.js

@@ -0,0 +1,1410 @@
+"use strict";
+/**
+ * Bitrix24 (Pragma) — Основная CRM Нода
+ *
+ * Bitrix24 PRAGMA.by nodes for n8n
+ * Профессиональная интеграция с Битрикс24 CRM.
+ * Поддержка: Лиды, Сделки, Контакты, Компании, Предложения, Смарт-процессы.
+ *
+ * @author PRAGMA & Азбука Решений
+ * @copyright 2026 PRAGMA (https://pragma.by/) & Азбука Решений (https://abc-solution.ru/)
+ * @version 1.0.0
+ *
+ * Контакты для заказа разработки:
+ * 🇧🇾 PRAGMA: +375 (44) 702-70-90 | https://pragma.by/
+ * 🇷🇺 Азбука Решений: +7 (939) 555-19-60 | https://abc-solution.ru/
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Bitrix24 = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const types_1 = require("./types");
+const Helpers_1 = require("./Helpers"); // Standard 2026: Helper
+const Lead_1 = require("./Lead");
+const Deal_1 = require("./Deal");
+const Contact_1 = require("./Contact");
+const Company_1 = require("./Company");
+class Bitrix24 {
+    constructor() {
+        this.description = {
+            displayName: 'Bitrix24 (Pragma)',
+            name: 'pragmaBitrix24',
+            icon: 'file:bitrix24.svg',
+            group: ['transform'],
+            version: 1,
+            subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
+            description: 'Работа с Битрикс24 CRM — лиды, сделки, контакты, компании и другие сущности',
+            defaults: {
+                name: 'Bitrix24 CRM',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            credentials: [
+                {
+                    name: 'bitrix24Api',
+                    required: true,
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Ресурс',
+                    name: 'resource',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        // Описания ресурсов CRM на русском языке
+                        {
+                            name: Lead_1.Lead.getDescription().name,
+                            value: Lead_1.Lead.getDescription().value,
+                            description: 'Управление лидами в CRM. <a href="https://training.bitrix24.com/rest_help/crm/leads/" target="_blank">Документация</a>'
+                        },
+                        {
+                            name: Deal_1.Deal.getDescription().name,
+                            value: Deal_1.Deal.getDescription().value,
+                            description: 'Управление сделками в CRM. <a href="https://training.bitrix24.com/rest_help/crm/deals/" target="_blank">Документация</a>'
+                        },
+                        {
+                            name: Contact_1.Contact.getDescription().name,
+                            value: Contact_1.Contact.getDescription().value,
+                            description: 'Управление контактами в CRM. <a href="https://training.bitrix24.com/rest_help/crm/contacts/" target="_blank">Документация</a>'
+                        },
+                        {
+                            name: Company_1.Company.getDescription().name,
+                            value: 'company',
+                            description: 'Управление компаниями в CRM. <a href="https://training.bitrix24.com/rest_help/crm/companies/" target="_blank">Документация</a>'
+                        },
+                        {
+                            name: 'Смарт-процесс (SPA)',
+                            value: 'smart_process',
+                            description: 'Управление динамическими сущностями (Smart Process Automation)',
+                        },
+                        {
+                            name: 'Реквизиты',
+                            value: 'requisite',
+                            description: 'Управление реквизитами компаний/контактов (платёжные данные)',
+                        },
+                        {
+                            name: 'Товары (Строки)',
+                            value: 'productrow',
+                            description: 'Управление товарными позициями в сделках/лидах',
+                        },
+                        {
+                            name: 'Воронка (Направление)',
+                            value: 'category',
+                            description: 'Управление воронками продаж',
+                        },
+                        {
+                            name: 'Стадия (Статус)',
+                            value: 'status',
+                            description: 'Управление стадиями и статусами CRM',
+                        },
+                        {
+                            name: 'Произвольный (Raw)',
+                            value: 'other',
+                            description: 'Вызов любого метода Bitrix24 API',
+                        },
+                        {
+                            name: 'Предложение (Смета)',
+                            value: 'quote',
+                            description: 'Управление коммерческими предложениями',
+                        },
+                    ],
+                    default: 'lead',
+                    required: true,
+                },
+                {
+                    displayName: 'Операция',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        {
+                            name: 'Создать',
+                            value: 'create',
+                            description: 'Создать новую запись',
+                            action: 'Создать запись',
+                            displayOptions: {
+                                hide: {
+                                    resource: ['other'],
+                                },
+                            },
+                        },
+                        {
+                            name: 'Получить',
+                            value: 'get',
+                            description: 'Получить запись по ID',
+                            action: 'Получить запись',
+                            displayOptions: {
+                                hide: {
+                                    resource: ['other'],
+                                },
+                            },
+                        },
+                        {
+                            name: 'Список',
+                            value: 'list',
+                            description: 'Получить список записей',
+                            action: 'Получить список',
+                            displayOptions: {
+                                hide: {
+                                    resource: ['other'],
+                                },
+                            },
+                        },
+                        {
+                            name: 'Обновить',
+                            value: 'update',
+                            description: 'Обновить запись',
+                            action: 'Обновить запись',
+                            displayOptions: {
+                                hide: {
+                                    resource: ['other'],
+                                },
+                            },
+                        },
+                        {
+                            name: 'Удалить',
+                            value: 'delete',
+                            description: 'Удалить запись',
+                            action: 'Удалить запись',
+                            displayOptions: {
+                                hide: {
+                                    resource: ['other'],
+                                },
+                            },
+                        },
+                        {
+                            name: 'Произвольный запрос',
+                            value: 'raw',
+                            description: 'Вызов любого метода API',
+                            action: 'Выполнить API запрос',
+                            displayOptions: {
+                                show: {
+                                    resource: ['other'],
+                                },
+                            },
+                        },
+                    ],
+                    default: 'create',
+                    required: true,
+                },
+                // ----------------------------------
+                // Поля Предложения
+                // ----------------------------------
+                {
+                    displayName: 'Тема предложения',
+                    name: 'quoteSubject',
+                    type: 'string',
+                    default: '',
+                    placeholder: 'Коммерческое предложение клиенту',
+                    displayOptions: {
+                        show: {
+                            resource: ['quote'],
+                            operation: ['create', 'update'],
+                        },
+                    },
+                    description: 'Тема/название коммерческого предложения',
+                },
+                {
+                    displayName: 'ID сделки (привязка)',
+                    name: 'dealId',
+                    type: 'string',
+                    default: '',
+                    placeholder: '123',
+                    hint: 'ID сделки для привязки предложения',
+                    displayOptions: {
+                        show: {
+                            resource: ['quote'],
+                            operation: ['create'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'ID компании',
+                    name: 'companyId',
+                    type: 'string',
+                    default: '',
+                    placeholder: '456',
+                    hint: 'ID компании-клиента',
+                    displayOptions: {
+                        show: {
+                            resource: ['quote'],
+                            operation: ['create'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'ID контакта',
+                    name: 'contactId',
+                    type: 'string',
+                    default: '',
+                    placeholder: '789',
+                    hint: 'ID контакта-клиента',
+                    displayOptions: {
+                        show: {
+                            resource: ['quote'],
+                            operation: ['create'],
+                        },
+                    },
+                },
+                // ----------------------------------
+                // Поля Сделки/Лида
+                // ----------------------------------
+                {
+                    displayName: 'Название',
+                    name: 'title',
+                    type: 'string',
+                    default: '',
+                    placeholder: 'Новая сделка с Компанией ABC',
+                    displayOptions: {
+                        show: {
+                            resource: ['lead', 'deal'],
+                            operation: ['create'],
+                        },
+                    },
+                    description: 'Название сделки или лида',
+                },
+                {
+                    displayName: 'Ответственный',
+                    name: 'assignedById',
+                    type: 'options',
+                    typeOptions: {
+                        loadOptionsMethod: 'getUsers',
+                    },
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['lead', 'deal', 'contact', 'company'],
+                            operation: ['create'],
+                        },
+                    },
+                    description: 'Пользователь, ответственный за сущность',
+                },
+                // Статус лида
+                {
+                    displayName: 'Статус',
+                    name: 'statusId',
+                    type: 'options',
+                    typeOptions: {
+                        loadOptionsMethod: 'getLeadStatuses',
+                    },
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['lead'],
+                            operation: ['create'],
+                        },
+                    },
+                    description: 'Текущий статус лида в воронке. Выберите из списка доступных статусов.',
+                    hint: 'Статусы настраиваются в CRM → Настройки → Стадии и статусы',
+                },
+                // Воронка и стадия сделки
+                {
+                    displayName: 'Воронка (Направление)',
+                    name: 'categoryId',
+                    type: 'options',
+                    typeOptions: {
+                        loadOptionsMethod: 'getDealCategories',
+                    },
+                    default: '0',
+                    displayOptions: {
+                        show: {
+                            resource: ['deal'],
+                            operation: ['create', 'update'],
+                        },
+                    },
+                    description: 'Воронка продаж для сделки. Каждая воронка имеет свои стадии.',
+                    hint: '0 = Общая воронка. Дополнительные создаются в CRM → Настройки',
+                },
+                {
+                    displayName: 'Стадия',
+                    name: 'stageId',
+                    type: 'options',
+                    typeOptions: {
+                        loadOptionsMethod: 'getDealStages',
+                        loadOptionsDependsOn: ['categoryId'],
+                    },
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['deal'],
+                            operation: ['create', 'update'],
+                        },
+                    },
+                    description: 'Текущая стадия сделки в выбранной воронке',
+                    hint: 'Список стадий зависит от выбранной воронки',
+                },
+                {
+                    displayName: 'Тип смарт-процесса',
+                    name: 'smartProcessId',
+                    type: 'options',
+                    typeOptions: {
+                        loadOptionsMethod: 'getSmartProcesses',
+                    },
+                    default: '',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['smart_process'],
+                        },
+                    },
+                    description: 'Выберите тип динамической сущности (Smart Process Automation)',
+                    hint: 'Смарт-процессы создаются в CRM → Настройки → CRM → Смарт-процессы',
+                },
+                // Поля произвольного запроса
+                {
+                    displayName: 'Метод HTTP',
+                    name: 'method',
+                    type: 'options',
+                    options: [
+                        { name: 'GET', value: 'GET' },
+                        { name: 'POST', value: 'POST' },
+                    ],
+                    default: 'POST',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['other'],
+                            operation: ['raw'],
+                        },
+                    },
+                    description: 'HTTP-метод запроса. Большинство методов Битрикс24 используют POST.',
+                    hint: 'POST — для создания/изменения, GET — для получения данных',
+                },
+                {
+                    displayName: 'Метод API',
+                    name: 'endpoint',
+                    type: 'string',
+                    default: '',
+                    placeholder: 'crm.lead.add',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['other'],
+                            operation: ['raw'],
+                        },
+                    },
+                    description: 'Название метода REST API Битрикс24 для вызова',
+                    hint: 'Список методов: <a href="https://training.bitrix24.com/rest_help/" target="_blank">training.bitrix24.com/rest_help</a>',
+                },
+                {
+                    displayName: 'Тело запроса (JSON)',
+                    name: 'jsonBody',
+                    type: 'json',
+                    default: '{}',
+                    displayOptions: {
+                        show: {
+                            resource: ['other'],
+                            operation: ['raw'],
+                        },
+                    },
+                    description: 'JSON-объект с параметрами запроса. Структура зависит от метода API.',
+                    hint: 'Пример: {"fields": {"TITLE": "Новый лид", "NAME": "Иван"}}',
+                },
+                // Поле ID
+                {
+                    displayName: 'Получить по',
+                    name: 'getBy',
+                    type: 'options',
+                    options: [
+                        {
+                            name: 'ID',
+                            value: 'id',
+                            description: 'Получить по идентификатору',
+                        },
+                        {
+                            name: 'Фильтр',
+                            value: 'filter',
+                            description: 'Получить по условию фильтра',
+                        },
+                    ],
+                    default: 'id',
+                    displayOptions: {
+                        show: {
+                            operation: ['get'],
+                        },
+                    },
+                    description: 'Способ поиска записи',
+                    hint: 'ID — быстрее, Фильтр — гибче',
+                },
+                {
+                    displayName: 'ID записи',
+                    name: 'id',
+                    type: 'string',
+                    default: '',
+                    required: true,
+                    placeholder: '123 или 123,124,125',
+                    displayOptions: {
+                        show: {
+                            operation: ['get'],
+                            getBy: ['id'],
+                        },
+                    },
+                    description: 'Уникальный идентификатор записи. Для нескольких записей укажите ID через запятую.',
+                    hint: 'Пример: 10,11,12 для получения трёх записей одним запросом',
+                },
+                {
+                    displayName: 'Компактный режим',
+                    name: 'compactMode',
+                    type: 'boolean',
+                    default: false,
+                    description: 'Скрыть пустые и служебные поля в результате для уменьшения объёма данных',
+                    hint: 'Рекомендуется для AI-интеграций и больших объёмов данных',
+                },
+                {
+                    displayName: 'Filter Fields',
+                    name: 'filterFields',
+                    type: 'fixedCollection',
+                    typeOptions: {
+                        multipleValues: true,
+                        sortable: true,
+                    },
+                    placeholder: 'Add Filter Field',
+                    default: {},
+                    options: [
+                        {
+                            name: 'field',
+                            displayName: 'Fields',
+                            values: [
+                                {
+                                    displayName: 'Field Name',
+                                    name: 'fieldName',
+                                    type: 'options',
+                                    typeOptions: {
+                                        loadOptionsMethod: 'getFields',
+                                    },
+                                    default: '',
+                                    description: 'Name of the field to filter by',
+                                },
+                                {
+                                    displayName: 'Operation',
+                                    name: 'operation',
+                                    type: 'options',
+                                    options: [
+                                        { name: 'Equals', value: 'equals' },
+                                        { name: 'Not Equals', value: '!=' },
+                                        { name: 'Greater Than', value: '>' },
+                                        { name: 'Greater Than or Equal', value: '>=' },
+                                        { name: 'Less Than', value: '<' },
+                                        { name: 'Less Than or Equal', value: '<=' },
+                                        { name: 'Contains', value: '%' },
+                                        { name: 'Not Contains', value: '!%' },
+                                        { name: 'Starts With', value: '=%' },
+                                        { name: 'Ends With', value: '%=' },
+                                        { name: 'In List', value: '@' },
+                                        { name: 'Not In List', value: '!@' },
+                                    ],
+                                    default: 'equals',
+                                    description: 'Comparison operation',
+                                },
+                                {
+                                    displayName: 'Value',
+                                    name: 'value',
+                                    type: 'string',
+                                    default: '',
+                                    description: 'Filter value',
+                                },
+                            ],
+                        },
+                    ],
+                    displayOptions: {
+                        show: {
+                            operation: ['get'],
+                            getBy: ['filter'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'ID',
+                    name: 'id',
+                    type: 'string',
+                    default: '',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            operation: ['update', 'delete'],
+                        },
+                    },
+                    description: 'Record ID',
+                },
+                // Input Format Selection
+                {
+                    displayName: 'Input Format',
+                    name: 'inputFormat',
+                    type: 'options',
+                    options: [
+                        {
+                            name: 'Form',
+                            value: 'form',
+                            description: 'Use form for field input',
+                        },
+                        {
+                            name: 'JSON',
+                            value: 'json',
+                            description: 'Use JSON format for field input',
+                        },
+                    ],
+                    default: 'form',
+                    displayOptions: {
+                        show: {
+                            operation: ['create', 'update'],
+                        },
+                    },
+                },
+                // JSON Fields
+                {
+                    displayName: 'Fields (JSON)',
+                    name: 'fieldsJson',
+                    type: 'json',
+                    default: '{}',
+                    description: 'Fields in JSON format',
+                    displayOptions: {
+                        show: {
+                            operation: ['create', 'update'],
+                            inputFormat: ['json'],
+                        },
+                    },
+                },
+                // Form Fields
+                {
+                    displayName: 'Fields',
+                    name: 'fields',
+                    type: 'fixedCollection',
+                    typeOptions: {
+                        multipleValues: true,
+                        sortable: true,
+                    },
+                    placeholder: 'Add Field',
+                    default: {},
+                    options: [
+                        {
+                            name: 'field',
+                            displayName: 'Fields',
+                            values: [
+                                {
+                                    displayName: 'Field Name',
+                                    name: 'fieldName',
+                                    type: 'options',
+                                    typeOptions: {
+                                        loadOptionsMethod: 'getFields',
+                                    },
+                                    default: '',
+                                    description: 'Name of the field to update',
+                                },
+                                {
+                                    displayName: 'Communication Type',
+                                    name: 'fieldValueType',
+                                    type: 'options',
+                                    options: Contact_1.Contact.communicationTypes,
+                                    default: types_1.CommunicationType.WORK,
+                                    description: 'Type of contact data',
+                                    displayOptions: {
+                                        show: {
+                                            '/resource': ['contact'],
+                                        },
+                                    },
+                                },
+                                {
+                                    displayName: 'Field Value',
+                                    name: 'fieldValue',
+                                    type: 'options',
+                                    typeOptions: {
+                                        loadOptionsMethod: 'getEnumValues',
+                                        loadOptionsDependsOn: ['fieldName'],
+                                    },
+                                    displayOptions: {
+                                        show: {
+                                            '/operation': ['create', 'update'],
+                                            fieldValueType: ['enumeration'],
+                                        },
+                                    },
+                                    default: '',
+                                    description: 'Value of the field',
+                                },
+                                {
+                                    displayName: 'Field Value',
+                                    name: 'fieldValue',
+                                    type: 'string',
+                                    displayOptions: {
+                                        hide: {
+                                            fieldValueType: ['enumeration'],
+                                        },
+                                    },
+                                    default: '',
+                                    description: 'Value of the field',
+                                },
+                            ],
+                        },
+                    ],
+                    description: 'Fields for creation/update',
+                    displayOptions: {
+                        show: {
+                            operation: ['create', 'update'],
+                            inputFormat: ['form'],
+                        },
+                    },
+                },
+                // List Fields
+                {
+                    displayName: 'Return All',
+                    name: 'returnAll',
+                    type: 'boolean',
+                    default: false,
+                    description: 'Whether to return all results or only up to a given limit',
+                    displayOptions: {
+                        show: {
+                            operation: ['list'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Limit',
+                    name: 'limit',
+                    type: 'number',
+                    default: 50,
+                    description: 'Max number of results to return',
+                    displayOptions: {
+                        show: {
+                            operation: ['list'],
+                            returnAll: [false],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Use Filter',
+                    name: 'useFilter',
+                    type: 'boolean',
+                    default: false,
+                    description: 'Whether to filter the results',
+                    displayOptions: {
+                        show: {
+                            operation: ['list'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Filter Fields',
+                    name: 'filterFields',
+                    type: 'fixedCollection',
+                    typeOptions: {
+                        multipleValues: true,
+                        sortable: true,
+                    },
+                    placeholder: 'Add Filter Field',
+                    default: {},
+                    options: [
+                        {
+                            name: 'field',
+                            displayName: 'Fields',
+                            values: [
+                                {
+                                    displayName: 'Field Name',
+                                    name: 'fieldName',
+                                    type: 'options',
+                                    typeOptions: {
+                                        loadOptionsMethod: 'getFields',
+                                    },
+                                    default: '',
+                                    description: 'Name of the field to filter by',
+                                },
+                                {
+                                    displayName: 'Operation',
+                                    name: 'operation',
+                                    type: 'options',
+                                    options: [
+                                        { name: 'Equals', value: 'equals' },
+                                        { name: 'Not Equals', value: '!=' },
+                                        { name: 'Greater Than', value: '>' },
+                                        { name: 'Greater Than or Equal', value: '>=' },
+                                        { name: 'Less Than', value: '<' },
+                                        { name: 'Less Than or Equal', value: '<=' },
+                                        { name: 'Contains', value: '%' },
+                                        { name: 'Not Contains', value: '!%' },
+                                        { name: 'Starts With', value: '=%' },
+                                        { name: 'Ends With', value: '%=' },
+                                        { name: 'In List', value: '@' },
+                                        { name: 'Not In List', value: '!@' },
+                                    ],
+                                    default: 'equals',
+                                    description: 'Comparison operation',
+                                },
+                                {
+                                    displayName: 'Value',
+                                    name: 'value',
+                                    type: 'string',
+                                    default: '',
+                                    description: 'Filter value',
+                                },
+                            ],
+                        },
+                    ],
+                    displayOptions: {
+                        show: {
+                            operation: ['list'],
+                            useFilter: [true],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Select Fields',
+                    name: 'selectFields',
+                    type: 'multiOptions',
+                    typeOptions: {
+                        loadOptionsMethod: 'getFields',
+                    },
+                    default: [],
+                    description: 'Select fields to retrieve',
+                    displayOptions: {
+                        show: {
+                            operation: ['get', 'list'],
+                        },
+                    },
+                },
+            ],
+        };
+        this.methods = {
+            loadOptions: {
+                async getSmartProcesses() {
+                    try {
+                        const credentials = await this.getCredentials('bitrix24Api');
+                        if (!credentials)
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'No credentials returned!');
+                        const response = await this.helpers.httpRequest({
+                            method: 'GET',
+                            baseURL: credentials.webhookUrl,
+                            url: 'crm.type.list.json', // Standard 2026: SPA List
+                            json: true,
+                        });
+                        if (!response || !response.result || !response.result.types) {
+                            // Fallback if no types or different format
+                            return [];
+                        }
+                        const types = response.result.types;
+                        return types.map(t => ({
+                            name: t.title,
+                            value: t.entityTypeId.toString(),
+                        }));
+                    }
+                    catch (error) {
+                        // Fallback for older Bitrix versions
+                        return [];
+                    }
+                },
+                async getFields() {
+                    try {
+                        const credentials = await this.getCredentials('bitrix24Api');
+                        if (!credentials) {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'No credentials returned!');
+                        }
+                        let resource = this.getCurrentNodeParameter('resource');
+                        let endpoint = `crm.${resource}.fields`;
+                        // Standard 2026: SPA Fields Logic
+                        if (resource === 'smart_process') {
+                            const smartProcessId = this.getCurrentNodeParameter('smartProcessId');
+                            if (!smartProcessId)
+                                return [];
+                            endpoint = `crm.item.fields?entityTypeId=${smartProcessId}`;
+                        }
+                        // Standard 2026: Requisite Fields Logic
+                        if (resource === 'requisite') {
+                            endpoint = 'crm.requisite.fields';
+                        }
+                        const response = await this.helpers.httpRequest({
+                            method: 'GET',
+                            baseURL: credentials.webhookUrl,
+                            url: endpoint,
+                            json: true,
+                        });
+                        if (!response || !response.result) {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Invalid response from Bitrix24!');
+                        }
+                        const fields = response.result;
+                        const options = [];
+                        for (const [key, value] of Object.entries(fields)) {
+                            const fieldName = value.formLabel || value.listLabel || value.title || key;
+                            const description = [
+                                `Type: ${value.type}`,
+                                value.isRequired ? 'Required' : 'Optional',
+                                value.isReadOnly ? 'Read-only' : 'Read/Write',
+                                value.isMultiple ? 'Multiple' : 'Single',
+                            ].join(', ');
+                            options.push({
+                                name: fieldName,
+                                value: key,
+                                description,
+                            });
+                        }
+                        return options;
+                    }
+                    catch (error) {
+                        if (error instanceof n8n_workflow_1.NodeOperationError) {
+                            throw error;
+                        }
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Failed to load fields: ' + error.message);
+                    }
+                },
+                async getEnumValues() {
+                    try {
+                        const credentials = await this.getCredentials('bitrix24Api');
+                        if (!credentials) {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'No credentials returned!');
+                        }
+                        let resource = this.getCurrentNodeParameter('resource');
+                        let endpoint = `crm.${resource}.fields`;
+                        if (resource === 'smart_process') {
+                            const smartProcessId = this.getCurrentNodeParameter('smartProcessId');
+                            endpoint = `crm.item.fields?entityTypeId=${smartProcessId}`;
+                        }
+                        if (resource === 'requisite') {
+                            endpoint = 'crm.requisite.fields';
+                        }
+                        const fieldsData = this.getCurrentNodeParameter('fields');
+                        const fieldName = fieldsData?.field?.[0]?.fieldName;
+                        if (!fieldName) {
+                            return [{ name: '- Select Field First -', value: '', description: 'Please select a field first' }];
+                        }
+                        const response = await this.helpers.httpRequest({
+                            method: 'GET',
+                            baseURL: credentials.webhookUrl,
+                            url: endpoint,
+                            json: true,
+                        });
+                        if (!response || !response.result) {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Invalid response from Bitrix24!');
+                        }
+                        const fieldsInfo = response.result;
+                        const field = fieldsInfo[fieldName];
+                        if (!field) {
+                            return [{ name: '- Field Not Found -', value: '', description: 'Field not found in Bitrix24 response' }];
+                        }
+                        if (field.type === 'enumeration' || (field.type === 'crm_status')) { // Handle generic status fields too
+                            if (field.items && Array.isArray(field.items)) {
+                                return field.items.map((item) => ({
+                                    name: item.VALUE,
+                                    value: item.VALUE,
+                                    description: `ID: ${item.ID}`,
+                                }));
+                            }
+                        }
+                        // Standard 2026: Dynamic Users
+                        if (field.type === 'user') {
+                            const userResponse = await this.helpers.httpRequest({
+                                method: 'POST',
+                                baseURL: credentials.webhookUrl,
+                                url: 'user.get.json',
+                                body: { FILTER: { ACTIVE: 'Y' } },
+                                json: true,
+                            });
+                            if (userResponse.result && Array.isArray(userResponse.result)) {
+                                return userResponse.result.map((u) => ({
+                                    name: `${u.NAME} ${u.LAST_NAME}`.trim(),
+                                    value: u.ID,
+                                    description: `ID: ${u.ID}`,
+                                }));
+                            }
+                        }
+                        // Standard 2026: Dynamic Currencies
+                        if (field.type === 'crm_currency') {
+                            const currResponse = await this.helpers.httpRequest({
+                                method: 'POST',
+                                baseURL: credentials.webhookUrl,
+                                url: 'crm.currency.list.json',
+                                json: true,
+                            });
+                            if (currResponse.result && Array.isArray(currResponse.result)) {
+                                return currResponse.result.map((c) => ({
+                                    name: c.FULL_NAME,
+                                    value: c.CURRENCY,
+                                    description: `Code: ${c.CURRENCY}`,
+                                }));
+                            }
+                        }
+                        return [{ name: '- Text Field (or Manual ID) -', value: '', description: 'Enter value manually' }];
+                    }
+                    catch (error) {
+                        if (error instanceof n8n_workflow_1.NodeOperationError) {
+                            throw error;
+                        }
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Failed to load enum values: ' + error.message);
+                    }
+                },
+                async getCrmCategories() {
+                    try {
+                        const credentials = await this.getCredentials('bitrix24Api');
+                        if (!credentials)
+                            return [];
+                        const resource = this.getCurrentNodeParameter('resource');
+                        if (resource !== 'deal') {
+                            return [{ name: 'General', value: '0' }];
+                        }
+                        const response = await this.helpers.httpRequest({
+                            method: 'POST',
+                            baseURL: credentials.webhookUrl,
+                            url: 'crm.category.list.json',
+                            body: { entityTypeId: 2 }, // 2 for Deal
+                            json: true,
+                        });
+                        const options = [{ name: 'General', value: '0' }];
+                        if (response.result && Array.isArray(response.result.categories)) {
+                            for (const cat of response.result.categories) {
+                                options.push({
+                                    name: cat.name,
+                                    value: cat.id.toString(),
+                                });
+                            }
+                        }
+                        return options;
+                    }
+                    catch (e) {
+                        return [{ name: 'General', value: '0' }];
+                    }
+                },
+                async getCrmStages() {
+                    try {
+                        const credentials = await this.getCredentials('bitrix24Api');
+                        if (!credentials)
+                            return [];
+                        const resource = this.getCurrentNodeParameter('resource');
+                        const categoryId = this.getCurrentNodeParameter('categoryId');
+                        let endpoint = 'crm.status.list.json';
+                        let body = {};
+                        if (resource === 'lead') {
+                            body = { FILTER: { ENTITY_ID: 'STATUS' } };
+                        }
+                        else if (resource === 'deal') {
+                            if (categoryId && categoryId !== '0') {
+                                endpoint = 'crm.dealcategory.stage.list.json';
+                                body = { id: categoryId };
+                            }
+                            else {
+                                body = { FILTER: { ENTITY_ID: 'DEAL_STAGE' } };
+                            }
+                        }
+                        else {
+                            return [];
+                        }
+                        const response = await this.helpers.httpRequest({
+                            method: 'POST',
+                            baseURL: credentials.webhookUrl,
+                            url: endpoint,
+                            body,
+                            json: true,
+                        });
+                        const options = [];
+                        if (Array.isArray(response.result)) {
+                            for (const stage of response.result) {
+                                options.push({
+                                    name: stage.NAME || stage.name, // .list returns NAME, .stage.list returns name
+                                    value: stage.STATUS_ID || stage.statusId,
+                                });
+                            }
+                        }
+                        return options;
+                    }
+                    catch (e) {
+                        return [];
+                    }
+                },
+            },
+        };
+    }
+    async execute() {
+        try {
+            const items = this.getInputData();
+            const returnData = [];
+            const resource = this.getNodeParameter('resource', 0);
+            const operation = this.getNodeParameter('operation', 0);
+            for (let i = 0; i < items.length; i++) {
+                try {
+                    if (operation === 'create' || operation === 'update') {
+                        let method = operation === 'create' ? 'add' : 'update';
+                        let endpoint = `crm.${resource}.${method}.json`;
+                        // Standard 2026: SPA Logic
+                        if (resource === 'smart_process') {
+                            endpoint = `crm.item.${method}.json`;
+                        }
+                        // Standard 2026: Requisite Logic
+                        if (resource === 'requisite') {
+                            endpoint = `crm.requisite.${method}.json`;
+                        }
+                        const inputFormat = this.getNodeParameter('inputFormat', i);
+                        let fields = {};
+                        if (inputFormat === 'json') {
+                            const fieldsJson = this.getNodeParameter('fieldsJson', i);
+                            if (typeof fieldsJson === 'string') {
+                                fields = JSON.parse(fieldsJson);
+                            }
+                            else {
+                                fields = fieldsJson;
+                            }
+                        }
+                        else {
+                            // Standard 2026: Fetch dynamic fields
+                            let fieldsEndpoint = `crm.${resource}.fields.json`;
+                            if (resource === 'smart_process') {
+                                const smartProcessId = this.getNodeParameter('smartProcessId', i);
+                                fieldsEndpoint = `crm.item.fields.json?entityTypeId=${smartProcessId}`;
+                            }
+                            if (resource === 'requisite') {
+                                fieldsEndpoint = 'crm.requisite.fields.json';
+                            }
+                            const fieldsResponse = await Helpers_1.bitrixRequestWithRetry.call(this, 'GET', fieldsEndpoint);
+                            const fieldsInfo = fieldsResponse.result;
+                            const fieldsCollection = this.getNodeParameter('fields.field', i, []);
+                            const enrichedFieldsCollection = fieldsCollection.map(field => {
+                                const fieldInfo = fieldsInfo[field.fieldName];
+                                let updatedFieldValueType = field.fieldValueType;
+                                if (fieldInfo && fieldInfo.type === 'enumeration') {
+                                    updatedFieldValueType = 'enumeration';
+                                }
+                                return {
+                                    ...field,
+                                    fieldValueType: updatedFieldValueType,
+                                    resource: resource,
+                                    field: fieldInfo,
+                                };
+                            });
+                            fields = (0, types_1.processFormFields)(enrichedFieldsCollection);
+                        }
+                        const body = { fields };
+                        // UX: Merge Top-Level Fields
+                        if (resource === 'quote') {
+                            const quoteSubject = this.getNodeParameter('quoteSubject', i, '');
+                            if (quoteSubject)
+                                fields['TITLE'] = quoteSubject;
+                            if (operation === 'create') {
+                                const dealId = this.getNodeParameter('dealId', i, '');
+                                if (dealId)
+                                    fields['DEAL_ID'] = dealId;
+                                const companyId = this.getNodeParameter('companyId', i, '');
+                                if (companyId)
+                                    fields['COMPANY_ID'] = companyId;
+                                const contactId = this.getNodeParameter('contactId', i, '');
+                                if (contactId)
+                                    fields['CONTACT_ID'] = contactId;
+                            }
+                        }
+                        const title = this.getNodeParameter('title', i, '');
+                        if (title)
+                            fields['TITLE'] = title;
+                        const assignedById = this.getNodeParameter('assignedById', i, '');
+                        if (assignedById)
+                            fields['ASSIGNED_BY_ID'] = assignedById;
+                        const statusId = this.getNodeParameter('statusId', i, '');
+                        if (statusId)
+                            fields['STATUS_ID'] = statusId;
+                        const categoryId = this.getNodeParameter('categoryId', i, '');
+                        if (categoryId && categoryId !== '0')
+                            fields['CATEGORY_ID'] = categoryId;
+                        const stageId = this.getNodeParameter('stageId', i, '');
+                        if (stageId)
+                            fields['STAGE_ID'] = stageId;
+                        // Standard 2026: SPA requires entityTypeId
+                        if (resource === 'smart_process') {
+                            const smartProcessId = this.getNodeParameter('smartProcessId', i);
+                            body.entityTypeId = smartProcessId;
+                        }
+                        if (operation === 'update') {
+                            body.id = this.getNodeParameter('id', i);
+                        }
+                        const response = await Helpers_1.bitrixRequestWithRetry.call(this, 'POST', endpoint, body);
+                        // Standard 2026: Direct Entity Link
+                        const result = response;
+                        if (resource !== 'requisite' && resource !== 'smart_process' && resource !== 'other') {
+                            const credentials = await this.getCredentials('bitrix24Api');
+                            const domain = credentials?.webhookUrl?.split('/rest')[0];
+                            // Construct URL: https://portal.bitrix24.com/crm/lead/details/123/
+                            if (domain && (result.result || body.id)) {
+                                const id = result.result || body.id;
+                                result.url = `${domain}/crm/${resource}/details/${id}/`;
+                            }
+                        }
+                        // SPA Link logic is complex (depends on routing), skipping for now to avoid broken links
+                        returnData.push({
+                            json: result,
+                            pairedItem: { item: i },
+                        });
+                    }
+                    // Standard 2026: Raw API Request Mode
+                    if (operation === 'raw') {
+                        const method = this.getNodeParameter('method', i);
+                        // Remove 'crm.' prefix if user typed it, or assume endpoint is full method name like 'crm.lead.add'
+                        // The helper appends base URL. Endpoint should be 'crm.lead.add.json' or 'crm.lead.add'
+                        let rawEndpoint = this.getNodeParameter('endpoint', i);
+                        if (!rawEndpoint.endsWith('.json'))
+                            rawEndpoint += '.json';
+                        const rawBody = this.getNodeParameter('jsonBody', i);
+                        let body = {};
+                        if (rawBody) {
+                            try {
+                                body = JSON.parse(rawBody);
+                            }
+                            catch (e) {
+                                throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Invalid JSON Body', { itemIndex: i });
+                            }
+                        }
+                        const response = await Helpers_1.bitrixRequestWithRetry.call(this, method, rawEndpoint, body);
+                        returnData.push({
+                            json: response,
+                            pairedItem: { item: i },
+                        });
+                    }
+                    if (operation === 'get') {
+                        const getBy = this.getNodeParameter('getBy', i);
+                        const selectFields = this.getNodeParameter('selectFields', i, []);
+                        const params = {};
+                        if (selectFields.length > 0) {
+                            params.select = selectFields;
+                        }
+                        else {
+                            let defaults = [];
+                            switch (resource) {
+                                case Lead_1.Lead.resource:
+                                    defaults = Lead_1.Lead.getDefaultFields();
+                                    break;
+                                case Deal_1.Deal.resource:
+                                    defaults = Deal_1.Deal.getDefaultFields();
+                                    break;
+                                case Contact_1.Contact.resource:
+                                    defaults = Contact_1.Contact.getDefaultFields();
+                                    break;
+                                case Company_1.Company.resource:
+                                    defaults = Company_1.Company.getDefaultFields();
+                                    break;
+                            }
+                            if (defaults.length)
+                                params.select = defaults;
+                        }
+                        let endpoint = `crm.${resource}.list.json`;
+                        // Standard 2026: SPA Logic
+                        if (resource === 'smart_process') {
+                            endpoint = 'crm.item.list.json';
+                            const smartProcessId = this.getNodeParameter('smartProcessId', i);
+                            params.entityTypeId = smartProcessId;
+                        }
+                        // Standard 2026: Requisite Logic
+                        if (resource === 'requisite') {
+                            endpoint = 'crm.requisite.list.json';
+                        }
+                        if (getBy === 'id') {
+                            const idInput = this.getNodeParameter('id', i);
+                            // Standard 2026: Bulk ID Input
+                            const ids = idInput.split(',').map(id => id.trim()).filter(id => id);
+                            if (ids.length > 1) {
+                                params.filter = { 'ID': ids }; // Bitrix supports array in filter
+                            }
+                            else {
+                                params.filter = { 'ID': ids[0] };
+                            }
+                        }
+                        else {
+                            const filterFields = this.getNodeParameter('filterFields.field', i, []);
+                            if (filterFields.length > 0) {
+                                const filter = {};
+                                for (const field of filterFields) {
+                                    let value = field.value;
+                                    if (field.operation === '@' || field.operation === '!@') {
+                                        value = value.split(',').map(item => item.trim());
+                                    }
+                                    if (field.operation === 'equals') {
+                                        filter[field.fieldName] = value;
+                                    }
+                                    else {
+                                        filter[field.operation + field.fieldName] = value;
+                                    }
+                                }
+                                params.filter = filter;
+                            }
+                        }
+                        const response = await Helpers_1.bitrixRequestWithRetry.call(this, 'POST', endpoint, params);
+                        const results = response.result; // Bitrix returns array for list/get calls
+                        if (results && Array.isArray(results) && results.length > 0) {
+                            for (const item of results) {
+                                // Standard 2026: Direct Entity Link
+                                if (resource !== 'requisite' && resource !== 'smart_process' && resource !== 'other') {
+                                    const credentials = await this.getCredentials('bitrix24Api');
+                                    const domain = credentials?.webhookUrl?.split('/rest')[0];
+                                    if (domain && item.ID) {
+                                        item.url = `${domain}/crm/${resource}/details/${item.ID}/`;
+                                    }
+                                }
+                                returnData.push({
+                                    json: item,
+                                    pairedItem: { item: i },
+                                });
+                            }
+                        }
+                        else {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Record not found', { itemIndex: i });
+                        }
+                    }
+                    if (operation === 'list') {
+                        const returnAll = this.getNodeParameter('returnAll', i);
+                        const selectFields = this.getNodeParameter('selectFields', i, []);
+                        const useFilter = this.getNodeParameter('useFilter', i);
+                        const body = {};
+                        if (selectFields.length > 0) {
+                            body.select = selectFields;
+                        }
+                        else {
+                            let defaults = [];
+                            switch (resource) {
+                                case Lead_1.Lead.resource:
+                                    defaults = Lead_1.Lead.getDefaultFields();
+                                    break;
+                                case Deal_1.Deal.resource:
+                                    defaults = Deal_1.Deal.getDefaultFields();
+                                    break;
+                                case Contact_1.Contact.resource:
+                                    defaults = Contact_1.Contact.getDefaultFields();
+                                    break;
+                                case Company_1.Company.resource:
+                                    defaults = Company_1.Company.getDefaultFields();
+                                    break;
+                            }
+                            if (defaults.length)
+                                body.select = defaults;
+                        }
+                        let endpoint = `crm.${resource}.list.json`;
+                        // Standard 2026: SPA Logic
+                        if (resource === 'smart_process') {
+                            endpoint = 'crm.item.list.json';
+                            const smartProcessId = this.getNodeParameter('smartProcessId', i);
+                            body.entityTypeId = smartProcessId;
+                        }
+                        // Standard 2026: Requisite Logic
+                        if (resource === 'requisite') {
+                            endpoint = 'crm.requisite.list.json';
+                        }
+                        if (useFilter) {
+                            const filterFields = this.getNodeParameter('filterFields.field', i, []);
+                            if (filterFields.length > 0) {
+                                const filter = {};
+                                for (const field of filterFields) {
+                                    let value = field.value;
+                                    if (field.operation === '@' || field.operation === '!@') {
+                                        value = value.split(',').map(item => item.trim());
+                                    }
+                                    if (field.operation === 'equals') {
+                                        filter[field.fieldName] = value;
+                                    }
+                                    else {
+                                        filter[field.operation + field.fieldName] = value;
+                                    }
+                                }
+                                body.filter = filter;
+                            }
+                        }
+                        const limit = returnAll ? 100000 : this.getNodeParameter('limit', i);
+                        if (returnAll) {
+                            let start = 0;
+                            let hasMore = true;
+                            // Standard 2026: Auto-Pagination Guard
+                            // Prevent infinite loops or OOM by limiting total pages
+                            let pageCount = 0;
+                            const MAX_PAGES = 500; // Limit to ~25,000 items per execution to be safe
+                            while (hasMore) {
+                                if (pageCount >= MAX_PAGES) {
+                                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Auto-Pagination Guard: Stopped after ${MAX_PAGES} pages (~25k items) to prevent memory crash. Please use 'Limit' or split your workflow.`);
+                                }
+                                pageCount++;
+                                body.start = start;
+                                const response = await Helpers_1.bitrixRequestWithRetry.call(this, 'POST', endpoint, body);
+                                const results = response.result;
+                                if (!results || results.length === 0) {
+                                    hasMore = false;
+                                }
+                                else {
+                                    for (const item of results) {
+                                        // Standard 2026: Direct Entity Link
+                                        if (resource !== 'requisite' && resource !== 'smart_process' && resource !== 'other') {
+                                            const credentials = await this.getCredentials('bitrix24Api');
+                                            const domain = credentials?.webhookUrl?.split('/rest')[0];
+                                            if (domain && item.ID) {
+                                                item.url = `${domain}/crm/${resource}/details/${item.ID}/`;
+                                            }
+                                        }
+                                        returnData.push({
+                                            json: item,
+                                            pairedItem: { item: i },
+                                        });
+                                    }
+                                    start += results.length;
+                                    if (results.length < 50)
+                                        hasMore = false;
+                                }
+                            }
+                        }
+                        else {
+                            const response = await Helpers_1.bitrixRequestWithRetry.call(this, 'POST', endpoint, body);
+                            const results = response.result;
+                            if (results) {
+                                for (let j = 0; j < results.length && j < limit; j++) {
+                                    const item = results[j];
+                                    // Standard 2026: Direct Entity Link
+                                    if (resource !== 'requisite' && resource !== 'smart_process' && resource !== 'other') {
+                                        const credentials = await this.getCredentials('bitrix24Api');
+                                        const domain = credentials?.webhookUrl?.split('/rest')[0];
+                                        if (domain && item.ID) {
+                                            item.url = `${domain}/crm/${resource}/details/${item.ID}/`;
+                                        }
+                                    }
+                                    returnData.push({
+                                        json: item,
+                                        pairedItem: { item: i },
+                                    });
+                                }
+                            }
+                        }
+                    }
+                    if (operation === 'delete') {
+                        const id = this.getNodeParameter('id', i);
+                        let endpoint = `crm.${resource}.delete.json`;
+                        const body = { id };
+                        // Standard 2026: SPA Logic
+                        if (resource === 'smart_process') {
+                            endpoint = 'crm.item.delete.json';
+                            const smartProcessId = this.getNodeParameter('smartProcessId', i);
+                            body.entityTypeId = smartProcessId;
+                        }
+                        // Standard 2026: Requisite Logic
+                        if (resource === 'requisite') {
+                            endpoint = 'crm.requisite.delete.json';
+                        }
+                        const response = await Helpers_1.bitrixRequestWithRetry.call(this, 'POST', endpoint, body);
+                        returnData.push({
+                            json: { success: true, id, result: response.result },
+                            pairedItem: { item: i },
+                        });
+                    }
+                }
+                catch (error) {
+                    if (this.continueOnFail()) {
+                        returnData.push({
+                            json: { error: error.message },
+                            pairedItem: { item: i },
+                        });
+                        continue;
+                    }
+                    throw error;
+                }
+            }
+            returnData.forEach(item => {
+                const pairedItem = item.pairedItem;
+                const index = (pairedItem && typeof pairedItem === 'object' && 'item' in pairedItem) ? pairedItem.item : 0;
+                if (this.getNodeParameter('compactMode', index, false)) {
+                    const json = item.json;
+                    Object.keys(json).forEach(key => {
+                        if (json[key] === null || json[key] === '' || (Array.isArray(json[key]) && json[key].length === 0)) {
+                            delete json[key];
+                        }
+                    });
+                }
+            });
+            return [returnData];
+        }
+        catch (error) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), error);
+        }
+    }
+}
+exports.Bitrix24 = Bitrix24;