n8n-nodes-pragma-bitrix24 1.0.0

package/dist/nodes/Bitrix24/Company.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Company = void 0;
+class Company {
+    static getDescription() {
+        return {
+            name: 'Company',
+            value: 'company',
+        };
+    }
+    // Методы специфичные для Company
+    static getDefaultFields() {
+        return ['TITLE', 'COMPANY_TYPE', 'INDUSTRY', 'PHONE', 'EMAIL', 'WEB', 'OPENED', 'ASSIGNED_BY_ID'];
+    }
+}
+exports.Company = Company;
+Company.resource = 'company';

package/dist/nodes/Bitrix24/Contact.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Contact = void 0;
+const types_1 = require("./types");
+class Contact {
+    static getDescription() {
+        return {
+            name: 'Contact',
+            value: 'contact',
+        };
+    }
+    // Методы специфичные для Contact
+    static getDefaultFields() {
+        return ['NAME', 'SECOND_NAME', 'LAST_NAME', 'PHONE', 'EMAIL', 'COMPANY_ID', 'OPENED', 'ASSIGNED_BY_ID', 'TYPE_ID'];
+    }
+}
+exports.Contact = Contact;
+Contact.resource = 'contact';
+// Типы значений для полей контакта
+Contact.communicationTypes = [
+    { name: 'Work', value: types_1.CommunicationType.WORK },
+    { name: 'Mobile', value: types_1.CommunicationType.MOBILE },
+    { name: 'Home', value: types_1.CommunicationType.HOME },
+    { name: 'Fax', value: types_1.CommunicationType.FAX },
+    { name: 'Telegram', value: types_1.CommunicationType.TELEGRAM },
+    { name: 'WhatsApp', value: types_1.CommunicationType.WHATSAPP },
+    { name: 'Viber', value: types_1.CommunicationType.VIBER },
+    { name: 'Facebook', value: types_1.CommunicationType.FACEBOOK },
+    { name: 'Skype', value: types_1.CommunicationType.SKYPE },
+    { name: 'Other', value: types_1.CommunicationType.OTHER },
+];

package/dist/nodes/Bitrix24/Deal.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Deal = void 0;
+class Deal {
+    static getDescription() {
+        return {
+            name: 'Deal',
+            value: 'deal',
+        };
+    }
+    // Методы специфичные для Deal
+    static getDefaultFields() {
+        return ['TITLE', 'TYPE_ID', 'STAGE_ID', 'OPPORTUNITY', 'CURRENCY_ID', 'COMPANY_ID', 'CONTACT_ID', 'OPENED', 'ASSIGNED_BY_ID'];
+    }
+}
+exports.Deal = Deal;
+Deal.resource = 'deal';

package/dist/nodes/Bitrix24/Helpers.js

@@ -0,0 +1,300 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BitrixSuccessSchema = exports.BitrixErrorSchema = void 0;
+exports.sleep = sleep;
+exports.safeJsonParse = safeJsonParse;
+exports.bitrixRequestWithRetry = bitrixRequestWithRetry;
+exports.bitrixBatchRequest = bitrixBatchRequest;
+exports.prepareBatchCommands = prepareBatchCommands;
+exports.bitrixFetchAll = bitrixFetchAll;
+const n8n_workflow_1 = require("n8n-workflow");
+const zod_1 = require("zod");
+const DEFAULT_CONFIG = {
+    minDelayMs: 100, // 10 req/sec for paid plans (use 500 for free)
+    maxDelayMs: 10000, // 10 seconds max
+    maxRetries: 5,
+    circuitBreakerThreshold: 5,
+    circuitBreakerTimeoutMs: 30000,
+};
+// ============================================
+// Zod Schemas for Runtime Validation
+// ============================================
+exports.BitrixErrorSchema = zod_1.z.object({
+    error: zod_1.z.string().optional(),
+    error_description: zod_1.z.string().optional(),
+    result: zod_1.z.unknown().optional(),
+});
+exports.BitrixSuccessSchema = zod_1.z.object({
+    result: zod_1.z.unknown(),
+    time: zod_1.z.record(zod_1.z.unknown()).optional(),
+    total: zod_1.z.number().optional(),
+    next: zod_1.z.number().optional(),
+});
+// ============================================
+// Utility Functions
+// ============================================
+/**
+ * Sleep helper for delays
+ */
+async function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Safely parse JSON with error handling
+ * @param jsonString - Raw JSON string
+ * @param fieldName - Field name for error messages
+ */
+function safeJsonParse(jsonString, fieldName = 'JSON') {
+    try {
+        return JSON.parse(jsonString);
+    }
+    catch (error) {
+        throw new Error(`Invalid ${fieldName}: ${error.message}. Please check the JSON syntax.`);
+    }
+}
+const circuitBreakerMap = new Map();
+function getCircuitBreaker(workflowId) {
+    if (!circuitBreakerMap.has(workflowId)) {
+        circuitBreakerMap.set(workflowId, { failures: 0, lastFailure: 0, isOpen: false });
+    }
+    return circuitBreakerMap.get(workflowId);
+}
+function resetCircuitBreaker(workflowId) {
+    const breaker = getCircuitBreaker(workflowId);
+    breaker.failures = 0;
+    breaker.isOpen = false;
+}
+function recordFailure(workflowId, config) {
+    const breaker = getCircuitBreaker(workflowId);
+    breaker.failures++;
+    breaker.lastFailure = Date.now();
+    if (breaker.failures >= config.circuitBreakerThreshold) {
+        breaker.isOpen = true;
+    }
+}
+const rateLimiterMap = new Map();
+function getRateLimiter(domain, config) {
+    if (!rateLimiterMap.has(domain)) {
+        rateLimiterMap.set(domain, { lastRequestTime: 0, currentDelay: config.minDelayMs });
+    }
+    return rateLimiterMap.get(domain);
+}
+async function waitForRateLimit(domain, config) {
+    const limiter = getRateLimiter(domain, config);
+    const now = Date.now();
+    const timeSinceLastRequest = now - limiter.lastRequestTime;
+    if (timeSinceLastRequest < limiter.currentDelay) {
+        await sleep(limiter.currentDelay - timeSinceLastRequest);
+    }
+    limiter.lastRequestTime = Date.now();
+}
+function updateRateLimitFromHeader(domain, retryAfter, config) {
+    const limiter = getRateLimiter(domain, config);
+    if (retryAfter) {
+        // Server told us to wait, increase delay
+        limiter.currentDelay = Math.min(retryAfter * 1000, config.maxDelayMs);
+    }
+    else {
+        // Success, gradually reduce delay
+        limiter.currentDelay = Math.max(limiter.currentDelay * 0.9, config.minDelayMs);
+    }
+}
+// ============================================
+// Main Request Function
+// ============================================
+/**
+ * Enhanced Bitrix24 API request with:
+ * - Adaptive rate limiting
+ * - Per-workflow circuit breaker
+ * - Exponential backoff
+ * - Rich error messages
+ */
+async function bitrixRequestWithRetry(method, endpoint, body = {}, qs = {}, overrideAuth, config = {}) {
+    const finalConfig = { ...DEFAULT_CONFIG, ...config };
+    const workflowId = this.getWorkflow().id?.toString() || 'default';
+    // Get domain for rate limiting
+    let domain = '';
+    let url = '';
+    if (overrideAuth) {
+        domain = overrideAuth.domain;
+        url = `https://${overrideAuth.domain}/rest/${endpoint}`;
+        qs.auth = overrideAuth.accessToken;
+    }
+    else {
+        const credentials = await this.getCredentials('bitrix24Api');
+        if (!credentials) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'No credentials returned!');
+        }
+        const webhookUrl = credentials.webhookUrl;
+        // Extract domain from webhook URL
+        const domainMatch = webhookUrl.match(/https?:\/\/([^/]+)/);
+        domain = domainMatch ? domainMatch[1] : 'unknown';
+        url = `${webhookUrl}${endpoint}`;
+    }
+    // Circuit Breaker Check
+    const breaker = getCircuitBreaker(workflowId);
+    if (breaker.isOpen) {
+        const timeSinceLastFailure = Date.now() - breaker.lastFailure;
+        if (timeSinceLastFailure < finalConfig.circuitBreakerTimeoutMs) {
+            const waitTime = Math.ceil((finalConfig.circuitBreakerTimeoutMs - timeSinceLastFailure) / 1000);
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Circuit Breaker Active: Bitrix24 API has too many failures. Wait ${waitTime}s or check API status.`, { description: 'The circuit breaker opens after 5 consecutive failures to prevent cascading errors.' });
+        }
+        // Reset if timeout passed
+        resetCircuitBreaker(workflowId);
+    }
+    let attempt = 0;
+    let delay = finalConfig.minDelayMs;
+    while (attempt < finalConfig.maxRetries) {
+        try {
+            // Wait for rate limit
+            await waitForRateLimit(domain, finalConfig);
+            const options = {
+                method,
+                url,
+                body,
+                qs,
+                json: true,
+                returnFullResponse: true, // Get headers for Retry-After
+            };
+            const response = await this.helpers.httpRequest(options);
+            const responseBody = response.body;
+            const headers = response.headers;
+            // Check for Retry-After header
+            const retryAfter = headers['retry-after'] ? parseInt(headers['retry-after'], 10) : undefined;
+            updateRateLimitFromHeader(domain, retryAfter, finalConfig);
+            // Runtime Validation
+            const parsed = exports.BitrixSuccessSchema.safeParse(responseBody);
+            if (!parsed.success) {
+                const errorParsed = exports.BitrixErrorSchema.safeParse(responseBody);
+                if (errorParsed.success && errorParsed.data.error) {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Bitrix24 API Error: ${errorParsed.data.error_description || errorParsed.data.error}`, { description: getErrorSuggestion(errorParsed.data.error_description || errorParsed.data.error) });
+                }
+            }
+            // Success! Reset breaker
+            resetCircuitBreaker(workflowId);
+            return responseBody;
+        }
+        catch (error) {
+            const err = error;
+            // Handle Rate Limiting (429) and Server Errors (5xx)
+            const status = err.response?.status;
+            if (status === 429 || (status && status >= 500 && status < 600)) {
+                attempt++;
+                // Check for Retry-After header on 429
+                const retryAfter = err.response?.headers?.['retry-after'];
+                if (retryAfter) {
+                    delay = parseInt(retryAfter, 10) * 1000;
+                    updateRateLimitFromHeader(domain, parseInt(retryAfter, 10), finalConfig);
+                }
+                if (attempt >= finalConfig.maxRetries) {
+                    recordFailure(workflowId, finalConfig);
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Bitrix24 API Request Failed after ${finalConfig.maxRetries} attempts: ${err.message}`, { description: 'Consider reducing request frequency or upgrading your Bitrix24 plan.' });
+                }
+                await sleep(delay);
+                delay = Math.min(delay * 2, finalConfig.maxDelayMs); // Exponential backoff
+                continue;
+            }
+            // For other errors, throw immediately with helpful message
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), formatErrorMessage(err), { description: getErrorSuggestion(err.response?.data?.error_description || err.message) });
+        }
+    }
+    // Should never reach here, but TypeScript needs it
+    throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Unexpected error in Bitrix24 request handler');
+}
+// ============================================
+// Batch API Support
+// ============================================
+/**
+ * Execute multiple API calls in a single batch request
+ * More efficient than multiple individual requests
+ */
+async function bitrixBatchRequest(commands, haltOnError = false) {
+    return bitrixRequestWithRetry.call(this, 'POST', 'batch.json', {
+        halt: haltOnError ? 1 : 0,
+        cmd: commands,
+    });
+}
+/**
+ * Prepare batch commands for CRM operations
+ */
+function prepareBatchCommands(resource, method, items, prefix = 'cmd') {
+    const commands = {};
+    items.forEach((item, index) => {
+        const params = new URLSearchParams();
+        Object.entries(item).forEach(([key, value]) => {
+            if (typeof value === 'object') {
+                params.append(key, JSON.stringify(value));
+            }
+            else {
+                params.append(key, String(value));
+            }
+        });
+        commands[`${prefix}_${index}`] = `${resource}.${method}?${params.toString()}`;
+    });
+    return commands;
+}
+// ============================================
+// Error Handling Helpers
+// ============================================
+function formatErrorMessage(err) {
+    const apiError = err.response?.data;
+    if (apiError?.error_description) {
+        return `Bitrix24 Error: ${apiError.error_description}`;
+    }
+    if (apiError?.error) {
+        return `Bitrix24 Error: ${apiError.error}`;
+    }
+    return err.message;
+}
+function getErrorSuggestion(errorText) {
+    const suggestions = {
+        'ACCESS_DENIED': 'Your webhook or user lacks permissions for this action. Check scope settings in Bitrix24.',
+        'limit': 'You hit the API rate limit. Consider upgrading your Bitrix24 plan or reducing request frequency.',
+        'NOT_FOUND': 'The requested entity does not exist. Verify the ID is correct.',
+        'INVALID_CREDENTIALS': 'Your webhook URL is invalid or expired. Generate a new one in Bitrix24.',
+        'INVALID_REQUEST': 'The request parameters are incorrect. Check required fields.',
+        'METHOD_NOT_FOUND': 'This API method does not exist or is not available for your plan.',
+        'NO_AUTH_FOUND': 'Authentication failed. Verify your webhook URL includes a valid token.',
+        'QUERY_LIMIT_EXCEEDED': 'Too many items in query. Use pagination or reduce filter scope.',
+        'EXPIRED_TOKEN': 'OAuth token has expired. Reconnect your Bitrix24 integration.',
+    };
+    for (const [key, suggestion] of Object.entries(suggestions)) {
+        if (errorText.toLowerCase().includes(key.toLowerCase())) {
+            return suggestion;
+        }
+    }
+    return 'Check Bitrix24 API documentation for more details on this error.';
+}
+// ============================================
+// Pagination Helpers
+// ============================================
+/**
+ * Fetch all pages of a paginated response
+ * Includes safety limit to prevent memory issues
+ */
+async function bitrixFetchAll(method, endpoint, params = {}, maxPages = 100) {
+    const allResults = [];
+    let start = 0;
+    let page = 0;
+    while (page < maxPages) {
+        const response = await bitrixRequestWithRetry.call(this, method, endpoint, {
+            ...params,
+            start,
+        });
+        const results = response.result;
+        if (results && Array.isArray(results)) {
+            allResults.push(...results);
+        }
+        // Check if there are more pages
+        if (response.next === undefined || response.next === null) {
+            break;
+        }
+        start = response.next;
+        page++;
+    }
+    if (page >= maxPages) {
+        // Warn about pagination limit
+        this.logger?.warn?.(`Bitrix24: Stopped after ${maxPages} pages to prevent memory issues. Total fetched: ${allResults.length}`);
+    }
+    return allResults;
+}

package/dist/nodes/Bitrix24/Lead.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Lead = void 0;
+class Lead {
+    static getDescription() {
+        return {
+            name: 'Lead',
+            value: 'lead',
+        };
+    }
+    // Методы специфичные для Lead
+    static getDefaultFields() {
+        return ['TITLE', 'NAME', 'SECOND_NAME', 'LAST_NAME', 'STATUS_ID', 'OPENED', 'ASSIGNED_BY_ID', 'PHONE', 'EMAIL'];
+    }
+}
+exports.Lead = Lead;
+Lead.resource = 'lead';

package/dist/nodes/Bitrix24/SmartProcess.js

@@ -0,0 +1 @@
+"use strict";

package/dist/nodes/Bitrix24/bitrix24.svg

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg width="32px" height="32px" viewBox="0 0 32 32" version="1.1" xmlns="http://www.w3.org/2000/svg">
+    <g stroke="none" stroke-width="1" fill="none" fill-rule="evenodd">
+        <path d="M16,0 C24.8365,0 32,7.1635 32,16 C32,24.8365 24.8365,32 16,32 C7.1635,32 0,24.8365 0,16 C0,7.1635 7.1635,0 16,0" fill="#2FC7F7"/>
+        <path d="M13.3333,8 L18.6667,8 C21.6122,8 24,10.3878 24,13.3333 L24,18.6667 C24,21.6122 21.6122,24 18.6667,24 L13.3333,24 C10.3878,24 8,21.6122 8,18.6667 L8,13.3333 C8,10.3878 10.3878,8 13.3333,8" fill="#FFFFFF"/>
+    </g>
+</svg> 

package/dist/nodes/Bitrix24/types.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sleep = exports.processFormFields = exports.formatCommunicationField = exports.formatContactCommunicationField = exports.CommunicationType = void 0;
+var CommunicationType;
+(function (CommunicationType) {
+    CommunicationType["WORK"] = "WORK";
+    CommunicationType["MOBILE"] = "MOBILE";
+    CommunicationType["HOME"] = "HOME";
+    CommunicationType["FAX"] = "FAX";
+    CommunicationType["OTHER"] = "OTHER";
+    CommunicationType["TELEGRAM"] = "TELEGRAM";
+    CommunicationType["WHATSAPP"] = "WHATSAPP";
+    CommunicationType["VIBER"] = "VIBER";
+    CommunicationType["FACEBOOK"] = "FACEBOOK";
+    CommunicationType["SKYPE"] = "SKYPE";
+})(CommunicationType || (exports.CommunicationType = CommunicationType = {}));
+// Формат для коммуникационных полей в сущности Contact
+const formatContactCommunicationField = (value, type = CommunicationType.WORK) => {
+    return [{ VALUE: value, VALUE_TYPE: type }];
+};
+exports.formatContactCommunicationField = formatContactCommunicationField;
+// Формат для коммуникационных полей для всех других сущностей
+const formatCommunicationField = (value, type = CommunicationType.WORK) => {
+    return [{ VALUE: value, TYPE: type }];
+};
+exports.formatCommunicationField = formatCommunicationField;
+const processFormFields = (fieldsCollection) => {
+    const fields = {};
+    for (const field of fieldsCollection) {
+        // Проверяем, является ли это полем связи (PHONE, EMAIL, IM, WEB)
+        if (['PHONE', 'EMAIL', 'IM', 'WEB'].some(type => field.fieldName.includes(type))) {
+            const valueType = field.fieldValueType || CommunicationType.WORK;
+            // Для полей контакта нужна специальная обработка
+            if (field.resource === 'contact') {
+                // Используем специальный формат для контактов
+                fields[field.fieldName] = (0, exports.formatContactCommunicationField)(field.fieldValue, valueType);
+            }
+            else {
+                // Для других сущностей используем стандартный формат
+                fields[field.fieldName] = (0, exports.formatCommunicationField)(field.fieldValue, valueType);
+            }
+        }
+        else if (field.field?.type === 'enumeration' && field.field.items && Array.isArray(field.field.items)) {
+            const selectedOption = field.field.items.find(item => item.VALUE === field.fieldValue);
+            if (selectedOption) {
+                fields[field.fieldName] = selectedOption.ID;
+            }
+        }
+        else {
+            fields[field.fieldName] = field.fieldValue;
+        }
+    }
+    return fields;
+};
+exports.processFormFields = processFormFields;
+// Helper function for rate limiting
+const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+exports.sleep = sleep;

package/dist/nodes/Bitrix24AI/Bitrix24AI.node.js

@@ -0,0 +1,205 @@
+"use strict";
+/**
+ * Bitrix24 AI — Нода управления AI-движками
+ *
+ * Bitrix24 PRAGMA.by nodes for n8n
+ * Профессиональная интеграция с Битрикс24.
+ *
+ * @author PRAGMA & Азбука Решений
+ * @copyright 2026 PRAGMA (https://pragma.by/) & Азбука Решений (https://abc-solution.ru/)
+ *
+ * Контакты:
+ * 🇧🇾 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.Bitrix24AI = void 0;
+const Helpers_1 = require("../Bitrix24/Helpers");
+class Bitrix24AI {
+    constructor() {
+        this.description = {
+            displayName: 'Bitrix24 AI Копилот',
+            name: 'bitrix24Ai',
+            icon: 'file:bitrix24.svg',
+            group: ['transform'],
+            version: 1,
+            subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
+            description: 'Управление AI-движками и промптами в Битрикс24 CoPilot',
+            defaults: {
+                name: 'Bitrix24 AI Копилот',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            credentials: [
+                {
+                    name: 'bitrix24Api',
+                    required: true,
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Resource',
+                    name: 'resource',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        {
+                            name: 'Engine',
+                            value: 'engine',
+                            description: 'Manage AI Engines',
+                        },
+                        {
+                            name: 'Prompt',
+                            value: 'prompt',
+                            description: 'Manage AI Prompts',
+                        },
+                    ],
+                    default: 'engine',
+                    required: true,
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        // Engine
+                        {
+                            name: 'Register',
+                            value: 'register',
+                            action: 'Register new AI Engine',
+                            displayOptions: { show: { resource: ['engine'] } },
+                        },
+                        {
+                            name: 'Unregister',
+                            value: 'unregister',
+                            action: 'Delete AI Engine',
+                            displayOptions: { show: { resource: ['engine'] } },
+                        },
+                        // Prompt
+                        {
+                            name: 'Register',
+                            value: 'register',
+                            action: 'Register new Prompt',
+                            displayOptions: { show: { resource: ['prompt'] } },
+                        },
+                        {
+                            name: 'Unregister',
+                            value: 'unregister',
+                            action: 'Delete Prompt',
+                            displayOptions: { show: { resource: ['prompt'] } },
+                        },
+                    ],
+                    default: 'register',
+                    required: true,
+                },
+                // Engine Fields
+                {
+                    displayName: 'Code',
+                    name: 'code',
+                    type: 'string',
+                    default: 'n8n_ai',
+                    displayOptions: { show: { resource: ['engine'], operation: ['register', 'unregister'] } },
+                    description: 'Unique code for the engine',
+                    required: true,
+                },
+                {
+                    displayName: 'Category',
+                    name: 'category',
+                    type: 'options',
+                    options: [
+                        { name: 'Text', value: 'text' },
+                        { name: 'Image', value: 'image' },
+                        { name: 'Audio', value: 'audio' },
+                    ],
+                    default: 'text',
+                    displayOptions: { show: { resource: ['engine'], operation: ['register'] } },
+                    required: true,
+                },
+                {
+                    displayName: 'Handler URL',
+                    name: 'handlerUrl',
+                    type: 'string',
+                    default: '',
+                    displayOptions: { show: { resource: ['engine'], operation: ['register'] } },
+                    description: 'Webhook URL of n8n workflow to handle completions',
+                    required: true,
+                },
+                {
+                    displayName: 'Name',
+                    name: 'name',
+                    type: 'string',
+                    default: 'n8n AI Model',
+                    displayOptions: { show: { resource: ['engine'], operation: ['register'] } },
+                },
+                // Prompt Fields
+                {
+                    displayName: 'Prompt Code',
+                    name: 'promptCode',
+                    type: 'string',
+                    default: '',
+                    displayOptions: { show: { resource: ['prompt'], operation: ['register', 'unregister'] } },
+                    required: true,
+                },
+                // Note: Prompt registration is complex, usually requires localizations etc.
+                // Simplified for now assuming basic usage.
+            ],
+        };
+    }
+    async execute() {
+        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 {
+                let endpoint = '';
+                let body = {};
+                if (resource === 'engine') {
+                    if (operation === 'register') {
+                        endpoint = 'ai.engine.register';
+                        body.CODE = this.getNodeParameter('code', i);
+                        body.CATEGORY = this.getNodeParameter('category', i);
+                        body.COM_HANDLER = this.getNodeParameter('handlerUrl', i);
+                        // Name implies Localization settings (more complex)
+                        // For now we assume user will manually config or simple pass
+                        // Actually AI engine registration is tricky.
+                    }
+                    else if (operation === 'unregister') {
+                        endpoint = 'ai.engine.unregister';
+                        body.CODE = this.getNodeParameter('code', i);
+                    }
+                }
+                else if (resource === 'prompt') {
+                    if (operation === 'register') {
+                        endpoint = 'ai.prompt.register';
+                        body.CODE = this.getNodeParameter('promptCode', i);
+                    }
+                    else if (operation === 'unregister') {
+                        endpoint = 'ai.prompt.unregister';
+                        body.CODE = this.getNodeParameter('promptCode', i);
+                    }
+                }
+                const response = await Helpers_1.bitrixRequestWithRetry.call(this, 'POST', endpoint, body);
+                let result = response.result;
+                if (Array.isArray(result)) {
+                    for (const item of result) {
+                        returnData.push({ json: item, pairedItem: { item: i } });
+                    }
+                }
+                else {
+                    returnData.push({ json: result, pairedItem: { item: i } });
+                }
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({ json: { error: error.message }, pairedItem: { item: i } });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    }
+}
+exports.Bitrix24AI = Bitrix24AI;