@catalogicus-international/n8n-nodes-telegram-advance 0.1.16 → 0.2.1

package/dist/credentials/TelegramAdvanceApi.credentials.js

@@ -25,6 +25,14 @@ class TelegramAdvanceApi {
                 required: true,
                 description: 'Telegram Bot API base URL, or the URL of a local Bot API server',
             },
+            {
+                displayName: 'Webhook Secret Token',
+                name: 'webhookSecret',
+                type: 'string',
+                typeOptions: { password: true },
+                default: '',
+                description: 'Optional secret used only by the Telegram Advance Webhook nodes. When set, it is passed to setWebhook as secret_token and every incoming update is verified against the X-Telegram-Bot-Api-Secret-Token header, so only Telegram can deliver updates to your webhook. Ignored by the long-polling nodes. 1–256 chars of A-Z, a-z, 0-9, _ and -.',
+            },
             {
                 displayName: 'Redis (Optional — Multi-Worker Coordination & Deduplication)',
                 name: 'redisNotice',

package/dist/credentials/TelegramAdvanceApi.credentials.js.map

@@ -1 +1 @@
-{"version":3,"file":"TelegramAdvanceApi.credentials.js","sourceRoot":"","sources":["../../credentials/TelegramAdvanceApi.credentials.ts"],"names":[],"mappings":";;;AAOA,MAAa,kBAAkB;IAA/B;QACC,SAAI,GAAG,oBAAoB,CAAC;QAE5B,gBAAW,GAAG,sBAAsB,CAAC;QAErC,SAAI,GAAS,4BAA4B,CAAC;QAE1C,qBAAgB,GAAG,4DAA4D,CAAC;QAEhF,eAAU,GAAsB;YAC/B;gBACC,WAAW,EAAE,kBAAkB;gBAC/B,IAAI,EAAE,aAAa;gBACnB,IAAI,EAAE,QAAQ;gBACd,WAAW,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE;gBAC/B,OAAO,EAAE,EAAE;gBACX,QAAQ,EAAE,IAAI;gBACd,WAAW,EAAE,6BAA6B;aAC1C;YACD;gBACC,WAAW,EAAE,UAAU;gBACvB,IAAI,EAAE,SAAS;gBACf,IAAI,EAAE,QAAQ;gBACd,OAAO,EAAE,0BAA0B;gBACnC,QAAQ,EAAE,IAAI;gBACd,WAAW,EAAE,iEAAiE;aAC9E;YACD;gBACC,WAAW,EAAE,8DAA8D;gBAC3E,IAAI,EAAE,aAAa;gBACnB,IAAI,EAAE,QAAQ;gBACd,OAAO,EAAE,EAAE;gBACX,WAAW,EACV,k3BAAk3B;aACn3B;YACD;gBACC,WAAW,EAAE,sBAAsB;gBACnC,IAAI,EAAE,UAAU;gBAChB,IAAI,EAAE,QAAQ;gBACd,OAAO,EAAE,EAAE;gBACX,WAAW,EAAE,8CAA8C;gBAC3D,WAAW,EACV,0UAA0U;aAC3U;YACD;gBACC,WAAW,EAAE,gBAAgB;gBAC7B,IAAI,EAAE,eAAe;gBACrB,IAAI,EAAE,QAAQ;gBACd,WAAW,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE;gBAC/B,OAAO,EAAE,EAAE;gBACX,WAAW,EACV,qIAAqI;gBACtI,cAAc,EAAE,EAAE,IAAI,EAAE,EAAE,QAAQ,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE;aAC/D;YACD;gBACC,WAAW,EAAE,qBAAqB;gBAClC,IAAI,EAAE,gBAAgB;gBACtB,IAAI,EAAE,QAAQ;gBACd,OAAO,EAAE,IAAI;gBACb,WAAW,EACV,+JAA+J;gBAChK,cAAc,EAAE,EAAE,IAAI,EAAE,EAAE,QAAQ,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE;aAC/D;SACD,CAAC;QAEF,iBAAY,GAAyB;YACpC,IAAI,EAAE,SAAS;YACf,UAAU,EAAE,EAAE;SACd,CAAC;IACH,CAAC;CAAA;AArED,gDAqEC"}
+{"version":3,"file":"TelegramAdvanceApi.credentials.js","sourceRoot":"","sources":["../../credentials/TelegramAdvanceApi.credentials.ts"],"names":[],"mappings":";;;AAOA,MAAa,kBAAkB;IAA/B;QACC,SAAI,GAAG,oBAAoB,CAAC;QAE5B,gBAAW,GAAG,sBAAsB,CAAC;QAErC,SAAI,GAAS,4BAA4B,CAAC;QAE1C,qBAAgB,GAAG,4DAA4D,CAAC;QAEhF,eAAU,GAAsB;YAC/B;gBACC,WAAW,EAAE,kBAAkB;gBAC/B,IAAI,EAAE,aAAa;gBACnB,IAAI,EAAE,QAAQ;gBACd,WAAW,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE;gBAC/B,OAAO,EAAE,EAAE;gBACX,QAAQ,EAAE,IAAI;gBACd,WAAW,EAAE,6BAA6B;aAC1C;YACD;gBACC,WAAW,EAAE,UAAU;gBACvB,IAAI,EAAE,SAAS;gBACf,IAAI,EAAE,QAAQ;gBACd,OAAO,EAAE,0BAA0B;gBACnC,QAAQ,EAAE,IAAI;gBACd,WAAW,EAAE,iEAAiE;aAC9E;YACD;gBACC,WAAW,EAAE,sBAAsB;gBACnC,IAAI,EAAE,eAAe;gBACrB,IAAI,EAAE,QAAQ;gBACd,WAAW,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE;gBAC/B,OAAO,EAAE,EAAE;gBACX,WAAW,EACV,iVAAiV;aAClV;YACD;gBACC,WAAW,EAAE,8DAA8D;gBAC3E,IAAI,EAAE,aAAa;gBACnB,IAAI,EAAE,QAAQ;gBACd,OAAO,EAAE,EAAE;gBACX,WAAW,EACV,k3BAAk3B;aACn3B;YACD;gBACC,WAAW,EAAE,sBAAsB;gBACnC,IAAI,EAAE,UAAU;gBAChB,IAAI,EAAE,QAAQ;gBACd,OAAO,EAAE,EAAE;gBACX,WAAW,EAAE,8CAA8C;gBAC3D,WAAW,EACV,0UAA0U;aAC3U;YACD;gBACC,WAAW,EAAE,gBAAgB;gBAC7B,IAAI,EAAE,eAAe;gBACrB,IAAI,EAAE,QAAQ;gBACd,WAAW,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE;gBAC/B,OAAO,EAAE,EAAE;gBACX,WAAW,EACV,qIAAqI;gBACtI,cAAc,EAAE,EAAE,IAAI,EAAE,EAAE,QAAQ,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE;aAC/D;YACD;gBACC,WAAW,EAAE,qBAAqB;gBAClC,IAAI,EAAE,gBAAgB;gBACtB,IAAI,EAAE,QAAQ;gBACd,OAAO,EAAE,IAAI;gBACb,WAAW,EACV,+JAA+J;gBAChK,cAAc,EAAE,EAAE,IAAI,EAAE,EAAE,QAAQ,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE;aAC/D;SACD,CAAC;QAEF,iBAAY,GAAyB;YACpC,IAAI,EAAE,SAAS;YACf,UAAU,EAAE,EAAE;SACd,CAAC;IACH,CAAC;CAAA;AA9ED,gDA8EC"}

package/dist/nodes/TelegramAdvance/TelegramAdvance.node.js

@@ -2,27 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TelegramAdvance = void 0;
 const n8n_workflow_1 = require("n8n-workflow");
-const question_1 = require("../question");
-const shared_1 = require("../shared");
-const transport_1 = require("../transport");
-const PollingCoordinator_1 = require("../coordinator/PollingCoordinator");
-const attachStore_1 = require("../coordinator/attachStore");
+const actionShared_1 = require("../actionShared");
 const credentialTest_1 = require("../credentialTest");
-function getWaitLimitMs(amount, unit) {
-    const multipliers = {
-        minutes: 60 * 1000,
-        hours: 60 * 60 * 1000,
-        days: 24 * 60 * 60 * 1000,
-    };
-    return Math.max(0, amount) * multipliers[unit];
-}
-async function bestEffort(operation) {
-    try {
-        await operation();
-    }
-    catch {
-    }
-}
 class TelegramAdvance {
     constructor() {
         this.description = {
@@ -45,402 +26,14 @@ class TelegramAdvance {
                     testedBy: 'telegramAdvanceApiCredentialTest',
                 },
             ],
-            properties: [
-                {
-                    displayName: 'Operation',
-                    name: 'operation',
-                    type: 'options',
-                    noDataExpression: true,
-                    options: [
-                        {
-                            name: 'Send and Wait for Response',
-                            value: 'sendAndWait',
-                            description: 'Ask a question in Telegram and wait for an in-chat response (approval, choice, or text)',
-                            action: 'Send a question and wait for a response',
-                        },
-                        {
-                            name: 'Send Message',
-                            value: 'send',
-                            description: 'Send a plain text message without waiting for a response',
-                            action: 'Send a text message',
-                        },
-                    ],
-                    default: 'sendAndWait',
-                },
-                {
-                    displayName: 'Self-Contained Wait',
-                    name: 'waitNotice',
-                    type: 'notice',
-                    default: '',
-                    description: 'This node sends the question and waits for an in-chat answer (inline button or reply) until the wait limit is reached. A single shared poller per bot handles getUpdates, so multiple questions can wait on the same bot at once. No public URL or separate trigger is required. Telegram allows only one getUpdates consumer per bot, so do not run a Telegram webhook or another poller on the same bot while a question is waiting.',
-                    displayOptions: { show: { operation: ['sendAndWait'] } },
-                },
-                {
-                    displayName: 'Chat ID',
-                    name: 'chatId',
-                    type: 'string',
-                    default: '={{ $json.message?.chat?.id || $json.chatId }}',
-                    required: true,
-                    description: 'Target Telegram chat ID',
-                },
-                {
-                    displayName: 'Text',
-                    name: 'text',
-                    type: 'string',
-                    typeOptions: { rows: 4 },
-                    default: '',
-                    required: true,
-                    description: 'Message text sent to the Telegram chat',
-                    displayOptions: { show: { operation: ['send'] } },
-                },
-                {
-                    displayName: 'Question',
-                    name: 'question',
-                    type: 'string',
-                    typeOptions: { rows: 4 },
-                    default: '',
-                    required: true,
-                    description: 'Message shown to the Telegram user',
-                    displayOptions: { show: { operation: ['sendAndWait'] } },
-                },
-                {
-                    displayName: 'Response Type',
-                    name: 'responseType',
-                    type: 'options',
-                    noDataExpression: true,
-                    displayOptions: { show: { operation: ['sendAndWait'] } },
-                    options: [
-                        {
-                            name: 'Approval',
-                            value: 'approval',
-                            description: 'Show approve and decline buttons',
-                            action: 'Wait for approval',
-                        },
-                        {
-                            name: 'Checkboxes',
-                            value: 'checkbox',
-                            description: 'Let the user select multiple items and confirm them with the submit button',
-                            action: 'Wait for selected items',
-                        },
-                        {
-                            name: 'Choice',
-                            value: 'choice',
-                            description: 'Show one or more custom choices, such as products',
-                            action: 'Wait for a choice',
-                        },
-                        {
-                            name: 'Free Text',
-                            value: 'text',
-                            description: 'Ask the user to reply to the Telegram message',
-                            action: 'Wait for a text reply',
-                        },
-                        {
-                            name: 'Radio Buttons',
-                            value: 'radio',
-                            description: 'Let the user select one item and confirm it with the submit button',
-                            action: 'Wait for one selected item',
-                        },
-                    ],
-                    default: 'approval',
-                },
-                {
-                    displayName: 'Approve Label',
-                    name: 'approveLabel',
-                    type: 'string',
-                    default: '✅ Approve',
-                    displayOptions: { show: { operation: ['sendAndWait'], responseType: ['approval'] } },
-                },
-                {
-                    displayName: 'Approve Value',
-                    name: 'approveValue',
-                    type: 'string',
-                    default: 'approved',
-                    displayOptions: { show: { operation: ['sendAndWait'], responseType: ['approval'] } },
-                },
-                {
-                    displayName: 'Decline Label',
-                    name: 'declineLabel',
-                    type: 'string',
-                    default: '❌ Decline',
-                    displayOptions: { show: { operation: ['sendAndWait'], responseType: ['approval'] } },
-                },
-                {
-                    displayName: 'Decline Value',
-                    name: 'declineValue',
-                    type: 'string',
-                    default: 'declined',
-                    displayOptions: { show: { operation: ['sendAndWait'], responseType: ['approval'] } },
-                },
-                {
-                    displayName: 'Display List',
-                    name: 'displayList',
-                    type: 'json',
-                    default: '[]',
-                    required: true,
-                    description: 'Optional non-clickable list shown above the approval buttons. Use an expression that returns strings, numbers, or objects with a label field.',
-                    displayOptions: {
-                        show: {
-                            operation: ['sendAndWait'],
-                            responseType: ['approval'],
-                        },
-                    },
-                },
-                {
-                    displayName: 'Choice Source',
-                    name: 'choiceSource',
-                    type: 'options',
-                    noDataExpression: true,
-                    default: 'fixed',
-                    displayOptions: {
-                        show: {
-                            operation: ['sendAndWait'],
-                            responseType: ['choice', 'radio', 'checkbox'],
-                        },
-                    },
-                    options: [
-                        {
-                            name: 'Define Below',
-                            value: 'fixed',
-                            description: 'Add labels and values manually',
-                        },
-                        {
-                            name: 'Expression',
-                            value: 'expression',
-                            description: 'Build the choices from an array returned by an expression',
-                        },
-                    ],
-                },
-                {
-                    displayName: 'Choices',
-                    name: 'choices',
-                    type: 'fixedCollection',
-                    typeOptions: { multipleValues: true },
-                    placeholder: 'Add Choice',
-                    default: {},
-                    displayOptions: {
-                        show: {
-                            operation: ['sendAndWait'],
-                            responseType: ['choice', 'radio', 'checkbox'],
-                            choiceSource: ['fixed'],
-                        },
-                    },
-                    options: [
-                        {
-                            displayName: 'Choice',
-                            name: 'choice',
-                            values: [
-                                {
-                                    displayName: 'Label',
-                                    name: 'label',
-                                    type: 'string',
-                                    default: '',
-                                    required: true,
-                                    description: 'Text shown on the Telegram button',
-                                },
-                                {
-                                    displayName: 'Value',
-                                    name: 'value',
-                                    type: 'string',
-                                    default: '',
-                                    required: true,
-                                    description: 'Value returned to the workflow',
-                                },
-                            ],
-                        },
-                    ],
-                },
-                {
-                    displayName: 'Dynamic Choices',
-                    name: 'dynamicChoices',
-                    type: 'json',
-                    default: '[]',
-                    required: true,
-                    description: 'A JSON array of objects with label and value fields. An expression can map source items and use their array index as the value.',
-                    displayOptions: {
-                        show: {
-                            operation: ['sendAndWait'],
-                            responseType: ['choice', 'radio', 'checkbox'],
-                            choiceSource: ['expression'],
-                        },
-                    },
-                },
-                {
-                    displayName: 'Buttons Per Row',
-                    name: 'buttonsPerRow',
-                    type: 'number',
-                    typeOptions: { minValue: 1, maxValue: 8 },
-                    default: 1,
-                    displayOptions: {
-                        show: {
-                            operation: ['sendAndWait'],
-                            responseType: ['approval', 'choice', 'radio', 'checkbox'],
-                        },
-                    },
-                },
-                {
-                    displayName: 'Submit Button Label',
-                    name: 'submitLabel',
-                    type: 'string',
-                    default: 'Отправить',
-                    required: true,
-                    description: 'Button that confirms the selected radio button or checkboxes',
-                    displayOptions: {
-                        show: {
-                            operation: ['sendAndWait'],
-                            responseType: ['radio', 'checkbox'],
-                        },
-                    },
-                },
-                {
-                    displayName: 'Reply Placeholder',
-                    name: 'inputPlaceholder',
-                    type: 'string',
-                    default: 'Type your answer…',
-                    displayOptions: { show: { operation: ['sendAndWait'], responseType: ['text'] } },
-                    description: 'Placeholder shown in the Telegram reply field',
-                },
-                {
-                    displayName: 'Options',
-                    name: 'sendOptions',
-                    type: 'collection',
-                    placeholder: 'Add Option',
-                    default: {},
-                    displayOptions: { show: { operation: ['send'] } },
-                    options: [
-                        {
-                            displayName: 'Disable Notification',
-                            name: 'disableNotification',
-                            type: 'boolean',
-                            default: false,
-                            description: 'Whether to send the message silently',
-                        },
-                        {
-                            displayName: 'Disable Link Preview',
-                            name: 'disableLinkPreview',
-                            type: 'boolean',
-                            default: false,
-                            description: 'Whether to disable link previews for links in the message',
-                        },
-                        {
-                            displayName: 'Parse Mode',
-                            name: 'parseMode',
-                            type: 'options',
-                            options: [
-                                { name: 'None', value: 'none' },
-                                { name: 'HTML', value: 'HTML' },
-                                { name: 'MarkdownV2', value: 'MarkdownV2' },
-                            ],
-                            default: 'none',
-                            description: 'How Telegram should parse formatting in the message',
-                        },
-                        {
-                            displayName: 'Reply To Message ID',
-                            name: 'replyToMessageId',
-                            type: 'number',
-                            default: 0,
-                            description: 'If set, the message is sent as a reply to this message ID in the chat',
-                        },
-                    ],
-                },
-                {
-                    displayName: 'Options',
-                    name: 'options',
-                    type: 'collection',
-                    placeholder: 'Add Option',
-                    default: {},
-                    displayOptions: { show: { operation: ['sendAndWait'] } },
-                    options: [
-                        {
-                            displayName: 'Acknowledgement Text',
-                            name: 'acknowledgementText',
-                            type: 'string',
-                            default: 'Response recorded',
-                            description: 'Toast shown for a button response, or message sent after a free-text response',
-                        },
-                        {
-                            displayName: 'Allowed User IDs',
-                            name: 'allowedUserIds',
-                            type: 'string',
-                            default: '',
-                            placeholder: '123456789, 987654321',
-                            description: 'Optional comma-separated Telegram user IDs. Empty allows any user in the chat.',
-                        },
-                        {
-                            displayName: 'Disable Notification',
-                            name: 'disableNotification',
-                            type: 'boolean',
-                            default: false,
-                            description: 'Whether to send the question silently',
-                        },
-                        {
-                            displayName: 'Expired Notice',
-                            name: 'expiredNotice',
-                            type: 'string',
-                            default: 'Запрос уже истёк',
-                            description: 'Toast shown to a user who taps a button after the wait limit has already passed',
-                        },
-                        {
-                            displayName: 'Parse Mode',
-                            name: 'parseMode',
-                            type: 'options',
-                            options: [
-                                { name: 'None', value: 'none' },
-                                { name: 'HTML', value: 'HTML' },
-                                { name: 'MarkdownV2', value: 'MarkdownV2' },
-                            ],
-                            default: 'none',
-                            description: 'How Telegram should parse formatting in the question',
-                        },
-                        {
-                            displayName: 'Remove Buttons After Response',
-                            name: 'removeButtons',
-                            type: 'boolean',
-                            default: true,
-                            description: 'Whether to remove inline buttons after the first response',
-                        },
-                    ],
-                },
-                {
-                    displayName: 'Wait Limit Amount',
-                    name: 'waitAmount',
-                    type: 'number',
-                    typeOptions: { minValue: 0.1, numberPrecision: 2 },
-                    default: 5,
-                    description: 'How long to keep polling Telegram for an answer before giving up. The node holds the execution open for this whole time, so prefer minutes for human-in-the-loop approvals.',
-                    displayOptions: { show: { operation: ['sendAndWait'] } },
-                },
-                {
-                    displayName: 'Wait Limit Unit',
-                    name: 'waitUnit',
-                    type: 'options',
-                    options: [
-                        { name: 'Days', value: 'days' },
-                        { name: 'Hours', value: 'hours' },
-                        { name: 'Minutes', value: 'minutes' },
-                    ],
-                    default: 'minutes',
-                    displayOptions: { show: { operation: ['sendAndWait'] } },
-                },
-                {
-                    displayName: 'On Timeout',
-                    name: 'onTimeout',
-                    type: 'options',
-                    options: [
-                        {
-                            name: 'Return Timeout Item',
-                            value: 'return',
-                            description: 'Continue the workflow with a timed-out item so you can branch on it',
-                        },
-                        {
-                            name: 'Throw Error',
-                            value: 'error',
-                            description: 'Fail the node if nobody answers within the wait limit',
-                        },
-                    ],
-                    default: 'return',
-                    displayOptions: { show: { operation: ['sendAndWait'] } },
-                },
-            ],
+            properties: (0, actionShared_1.buildActionProperties)({
+                displayName: 'Self-Contained Wait',
+                name: 'waitNotice',
+                type: 'notice',
+                default: '',
+                description: 'This node sends the question and waits for an in-chat answer (inline button or reply) until the wait limit is reached. A single shared poller per bot handles getUpdates, so multiple questions can wait on the same bot at once. No public URL or separate trigger is required. Telegram allows only one getUpdates consumer per bot, so do not run a Telegram webhook or another poller on the same bot while a question is waiting.',
+                displayOptions: { show: { operation: ['sendAndWait'] } },
+            }),
         };
         this.methods = {
             credentialTest: {
@@ -449,189 +42,7 @@ class TelegramAdvance {
         };
     }
     async execute() {
-        var _a, _b, _c;
-        const operation = this.getNodeParameter('operation', 0);
-        const inputData = this.getInputData();
-        if (operation === 'sendAndWait') {
-            let releaseReservation;
-            try {
-                if (inputData.length === 0)
-                    return [[]];
-                const chatId = String(this.getNodeParameter('chatId', 0)).trim();
-                const question = String(this.getNodeParameter('question', 0)).trim();
-                const responseType = this.getNodeParameter('responseType', 0);
-                const choiceSource = this.getNodeParameter('choiceSource', 0, 'fixed');
-                const buttonsPerRow = this.getNodeParameter('buttonsPerRow', 0, 1);
-                const inputPlaceholder = this.getNodeParameter('inputPlaceholder', 0, '');
-                const submitLabel = String(this.getNodeParameter('submitLabel', 0, 'Отправить')).trim();
-                const options = this.getNodeParameter('options', 0, {});
-                const parseMode = String(options.parseMode || 'none');
-                if (!chatId || !question) {
-                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Chat ID and Question are required');
-                }
-                const messageText = responseType === 'approval'
-                    ? (0, question_1.appendDisplayList)(question, (0, question_1.parseDisplayList)(this.getNodeParameter('displayList', 0, [])), parseMode)
-                    : question;
-                const responseOptions = (0, question_1.buildResponseOptions)(responseType, {
-                    approveLabel: this.getNodeParameter('approveLabel', 0, ''),
-                    approveValue: this.getNodeParameter('approveValue', 0, ''),
-                    declineLabel: this.getNodeParameter('declineLabel', 0, ''),
-                    declineValue: this.getNodeParameter('declineValue', 0, ''),
-                    choices: this.getNodeParameter('choices', 0, {}),
-                    choiceSource,
-                    dynamicChoices: choiceSource === 'expression'
-                        ? this.getNodeParameter('dynamicChoices', 0, [])
-                        : undefined,
-                });
-                const token = PollingCoordinator_1.PollingCoordinator.newToken();
-                const replyMarkup = (0, question_1.buildReplyMarkup)(responseType, token, responseOptions, Math.max(1, Math.min(8, buttonsPerRow)), inputPlaceholder, responseType === 'radio' || responseType === 'checkbox'
-                    ? { selectedIndices: [], submitLabel }
-                    : undefined);
-                const body = {
-                    chat_id: chatId,
-                    text: messageText,
-                    disable_notification: options.disableNotification === true,
-                    reply_markup: replyMarkup,
-                };
-                if (parseMode !== 'none')
-                    body.parse_mode = parseMode;
-                const transport = await (0, transport_1.createTransport)(this);
-                const coordinator = PollingCoordinator_1.PollingCoordinator.getInstance();
-                await transport.call('deleteWebhook', { drop_pending_updates: false });
-                await (0, attachStore_1.attachRedisStore)(this, coordinator);
-                const expiredNotice = String((_a = options.expiredNotice) !== null && _a !== void 0 ? _a : '');
-                const waitLimitMs = getWaitLimitMs(this.getNodeParameter('waitAmount', 0, 5), this.getNodeParameter('waitUnit', 0, 'minutes'));
-                coordinator.reserve(transport, token);
-                releaseReservation = () => coordinator.cancelReservation(transport, token);
-                const sentMessage = await transport.call('sendMessage', body);
-                const pending = {
-                    token,
-                    chatId,
-                    messageId: sentMessage.message_id,
-                    responseType,
-                    options: responseOptions,
-                    allowedUserIds: (0, question_1.parseUserIds)(options.allowedUserIds),
-                    expiredNotice,
-                    ...(responseType === 'radio' || responseType === 'checkbox'
-                        ? {
-                            selection: {
-                                selectedIndices: [],
-                                buttonsPerRow: Math.max(1, Math.min(8, buttonsPerRow)),
-                                submitLabel,
-                            },
-                        }
-                        : {}),
-                };
-                const acknowledgementText = String((_b = options.acknowledgementText) !== null && _b !== void 0 ? _b : 'Response recorded');
-                const removeButtons = options.removeButtons !== false;
-                const { wait } = await coordinator.register(transport, pending, waitLimitMs);
-                releaseReservation = undefined;
-                const matched = await wait;
-                if (!matched) {
-                    if (this.getNodeParameter('onTimeout', 0, 'return') === 'error') {
-                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'No Telegram response received before the wait limit');
-                    }
-                    return [
-                        [
-                            {
-                                json: {
-                                    timedOut: true,
-                                    questionMessageId: sentMessage.message_id,
-                                    chat: { id: chatId },
-                                },
-                                pairedItem: { item: 0 },
-                            },
-                        ],
-                    ];
-                }
-                if (matched.callbackQueryId) {
-                    await bestEffort(() => (0, shared_1.telegramApiRequest)(this, 'answerCallbackQuery', {
-                        callback_query_id: matched.callbackQueryId,
-                        ...(acknowledgementText ? { text: acknowledgementText.slice(0, 200) } : {}),
-                    }));
-                    if (removeButtons) {
-                        const chosenLabel = String((_c = matched.response.label) !== null && _c !== void 0 ? _c : '').trim();
-                        const editBody = {
-                            chat_id: chatId,
-                            message_id: sentMessage.message_id,
-                            reply_markup: { inline_keyboard: [] },
-                        };
-                        if (chosenLabel) {
-                            editBody.text = `${question}\n\n${chosenLabel}`;
-                            if (parseMode !== 'none')
-                                editBody.parse_mode = parseMode;
-                        }
-                        await bestEffort(() => (0, shared_1.telegramApiRequest)(this, chosenLabel ? 'editMessageText' : 'editMessageReplyMarkup', editBody));
-                    }
-                }
-                else if (acknowledgementText) {
-                    await bestEffort(() => (0, shared_1.telegramApiRequest)(this, 'sendMessage', {
-                        chat_id: chatId,
-                        text: acknowledgementText,
-                        reply_parameters: { message_id: matched.response.responseMessageId },
-                    }));
-                }
-                return [[{ json: { response: matched.response }, pairedItem: { item: 0 } }]];
-            }
-            catch (error) {
-                releaseReservation === null || releaseReservation === void 0 ? void 0 : releaseReservation();
-                if (this.continueOnFail()) {
-                    return [
-                        [
-                            {
-                                json: { error: error instanceof Error ? error.message : String(error) },
-                                pairedItem: { item: 0 },
-                            },
-                        ],
-                    ];
-                }
-                throw new n8n_workflow_1.NodeOperationError(this.getNode(), error, { itemIndex: 0 });
-            }
-        }
-        const returnData = [];
-        for (let itemIndex = 0; itemIndex < inputData.length; itemIndex++) {
-            try {
-                const chatId = String(this.getNodeParameter('chatId', itemIndex)).trim();
-                const text = String(this.getNodeParameter('text', itemIndex)).trim();
-                const options = this.getNodeParameter('sendOptions', itemIndex, {});
-                if (!chatId || !text) {
-                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Chat ID and Text are required', {
-                        itemIndex,
-                    });
-                }
-                const parseMode = String(options.parseMode || 'none');
-                const replyToMessageId = Number(options.replyToMessageId || 0);
-                const body = {
-                    chat_id: chatId,
-                    text,
-                    disable_notification: options.disableNotification === true,
-                };
-                if (parseMode !== 'none')
-                    body.parse_mode = parseMode;
-                if (options.disableLinkPreview === true) {
-                    body.link_preview_options = { is_disabled: true };
-                }
-                if (replyToMessageId > 0) {
-                    body.reply_parameters = { message_id: replyToMessageId };
-                }
-                const sentMessage = await (0, shared_1.telegramApiRequest)(this, 'sendMessage', body);
-                returnData.push({
-                    json: sentMessage,
-                    pairedItem: { item: itemIndex },
-                });
-            }
-            catch (error) {
-                if (this.continueOnFail()) {
-                    returnData.push({
-                        json: { error: error instanceof Error ? error.message : String(error) },
-                        pairedItem: { item: itemIndex },
-                    });
-                    continue;
-                }
-                throw new n8n_workflow_1.NodeOperationError(this.getNode(), error, { itemIndex });
-            }
-        }
-        return [returnData];
+        return (0, actionShared_1.runAction)(this, 'polling');
     }
 }
 exports.TelegramAdvance = TelegramAdvance;