n8n-nodes-mercadopago-pix-assinatura 1.0.0

package/dist/nodes/PixPayment/PixPayment.node.js

@@ -0,0 +1,1041 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PixPayment = void 0;
+const helpers_1 = require("./helpers");
+class PixPayment {
+    constructor() {
+        this.description = {
+            displayName: 'Mercado Pago PIX e Assinaturas',
+            name: 'pixPayment',
+            icon: 'file:mercadopago.svg',
+            group: ['transform'],
+            version: 1,
+            subtitle: '={{$parameter["resource"] + ": " + $parameter["operation"]}}',
+            description: 'Processamento de pagamentos PIX, assinaturas e webhooks via Mercado Pago',
+            defaults: {
+                name: 'Mercado Pago',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            credentials: [
+                {
+                    name: 'pixPaymentApi',
+                    required: true,
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Resource',
+                    name: 'resource',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        {
+                            name: 'PIX',
+                            value: 'pix',
+                        },
+                        {
+                            name: 'Assinatura',
+                            value: 'subscriptions',
+                        },
+                        {
+                            name: 'Pagamento Recorrente',
+                            value: 'recurringPayments',
+                        },
+                        {
+                            name: 'Webhook',
+                            value: 'webhooks',
+                        },
+                    ],
+                    default: 'pix',
+                },
+                // PIX Operations
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['pix'],
+                        },
+                    },
+                    options: [
+                        {
+                            name: 'Criar',
+                            value: 'create',
+                            description: 'Criar um pagamento PIX',
+                            action: 'Criar pagamento PIX',
+                        },
+                        {
+                            name: 'Consultar',
+                            value: 'get',
+                            description: 'Consultar um pagamento PIX',
+                            action: 'Consultar pagamento PIX',
+                        },
+                        {
+                            name: 'Reembolsar',
+                            value: 'refund',
+                            description: 'Reembolsar um pagamento PIX',
+                            action: 'Reembolsar pagamento PIX',
+                        },
+                    ],
+                    default: 'create',
+                },
+                // PIX Create Fields
+                {
+                    displayName: 'Valor',
+                    name: 'amount',
+                    type: 'number',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['pix'],
+                            operation: ['create'],
+                        },
+                    },
+                    default: 0,
+                    description: 'Valor do pagamento em reais (ex: 10.50)',
+                },
+                {
+                    displayName: 'Descrição',
+                    name: 'description',
+                    type: 'string',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['pix'],
+                            operation: ['create'],
+                        },
+                    },
+                    default: '',
+                    description: 'Descrição do pagamento',
+                },
+                {
+                    displayName: 'E-mail do Pagador',
+                    name: 'payerEmail',
+                    type: 'string',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['pix'],
+                            operation: ['create'],
+                        },
+                    },
+                    default: '',
+                    description: 'E-mail do pagador',
+                },
+                {
+                    displayName: 'CPF/CNPJ do Pagador',
+                    name: 'payerDocument',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            resource: ['pix'],
+                            operation: ['create'],
+                        },
+                    },
+                    default: '',
+                    description: 'CPF ou CNPJ do pagador (apenas números)',
+                },
+                {
+                    displayName: 'Nome do Pagador',
+                    name: 'payerName',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            resource: ['pix'],
+                            operation: ['create'],
+                        },
+                    },
+                    default: '',
+                    description: 'Nome completo do pagador',
+                },
+                {
+                    displayName: 'Data de Expiração',
+                    name: 'expirationDate',
+                    type: 'dateTime',
+                    displayOptions: {
+                        show: {
+                            resource: ['pix'],
+                            operation: ['create'],
+                        },
+                    },
+                    default: '',
+                    description: 'Data e hora de expiração do QR Code PIX',
+                },
+                {
+                    displayName: 'Referência Externa',
+                    name: 'externalReference',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            resource: ['pix'],
+                            operation: ['create'],
+                        },
+                    },
+                    default: '',
+                    description: 'Referência externa para identificar o pagamento',
+                },
+                {
+                    displayName: 'Chave de Idempotência',
+                    name: 'idempotencyKey',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            resource: ['pix'],
+                            operation: ['create'],
+                        },
+                    },
+                    default: '',
+                    description: 'Chave única para garantir idempotência da requisição',
+                },
+                // PIX Get Fields
+                {
+                    displayName: 'ID do Pagamento',
+                    name: 'paymentId',
+                    type: 'string',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['pix'],
+                            operation: ['get'],
+                        },
+                    },
+                    default: '',
+                    description: 'ID do pagamento a ser consultado',
+                },
+                // PIX Refund Fields
+                {
+                    displayName: 'ID do Pagamento',
+                    name: 'paymentId',
+                    type: 'string',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['pix'],
+                            operation: ['refund'],
+                        },
+                    },
+                    default: '',
+                    description: 'ID do pagamento a ser reembolsado',
+                },
+                {
+                    displayName: 'Valor do Reembolso',
+                    name: 'refundAmount',
+                    type: 'number',
+                    displayOptions: {
+                        show: {
+                            resource: ['pix'],
+                            operation: ['refund'],
+                        },
+                    },
+                    default: 0,
+                    description: 'Valor do reembolso em reais (deixe vazio para reembolso total)',
+                },
+                // Subscription Operations
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['subscriptions'],
+                        },
+                    },
+                    options: [
+                        {
+                            name: 'Criar',
+                            value: 'create',
+                            description: 'Criar uma assinatura',
+                            action: 'Criar assinatura',
+                        },
+                        {
+                            name: 'Pausar',
+                            value: 'pause',
+                            description: 'Pausar uma assinatura',
+                            action: 'Pausar assinatura',
+                        },
+                        {
+                            name: 'Retomar',
+                            value: 'resume',
+                            description: 'Retomar uma assinatura pausada',
+                            action: 'Retomar assinatura',
+                        },
+                        {
+                            name: 'Cancelar',
+                            value: 'cancel',
+                            description: 'Cancelar uma assinatura',
+                            action: 'Cancelar assinatura',
+                        },
+                        {
+                            name: 'Consultar',
+                            value: 'get',
+                            description: 'Consultar uma assinatura',
+                            action: 'Consultar assinatura',
+                        },
+                        {
+                            name: 'Listar',
+                            value: 'list',
+                            description: 'Listar assinaturas',
+                            action: 'Listar assinaturas',
+                        },
+                    ],
+                    default: 'create',
+                },
+                // Subscription Create Fields
+                {
+                    displayName: 'ID do Plano',
+                    name: 'planId',
+                    type: 'string',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['subscriptions'],
+                            operation: ['create'],
+                        },
+                    },
+                    default: '',
+                    description: 'ID do plano de assinatura',
+                },
+                {
+                    displayName: 'E-mail do Pagador',
+                    name: 'payerEmail',
+                    type: 'string',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['subscriptions'],
+                            operation: ['create'],
+                        },
+                    },
+                    default: '',
+                    description: 'E-mail do pagador',
+                },
+                {
+                    displayName: 'CPF/CNPJ do Pagador',
+                    name: 'payerDocument',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            resource: ['subscriptions'],
+                            operation: ['create'],
+                        },
+                    },
+                    default: '',
+                    description: 'CPF ou CNPJ do pagador',
+                },
+                {
+                    displayName: 'Data de Início',
+                    name: 'startDate',
+                    type: 'dateTime',
+                    displayOptions: {
+                        show: {
+                            resource: ['subscriptions'],
+                            operation: ['create'],
+                        },
+                    },
+                    default: '',
+                    description: 'Data de início da assinatura',
+                },
+                {
+                    displayName: 'Período de Trial (dias)',
+                    name: 'trialPeriodDays',
+                    type: 'number',
+                    displayOptions: {
+                        show: {
+                            resource: ['subscriptions'],
+                            operation: ['create'],
+                        },
+                    },
+                    default: 0,
+                    description: 'Número de dias de período de trial',
+                },
+                // Subscription Get/Cancel/Pause/Resume Fields
+                {
+                    displayName: 'ID da Assinatura',
+                    name: 'subscriptionId',
+                    type: 'string',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['subscriptions'],
+                            operation: ['get', 'cancel', 'pause', 'resume'],
+                        },
+                    },
+                    default: '',
+                    description: 'ID da assinatura',
+                },
+                // Recurring Payment Operations
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['recurringPayments'],
+                        },
+                    },
+                    options: [
+                        {
+                            name: 'Criar',
+                            value: 'create',
+                            description: 'Criar um pagamento recorrente',
+                            action: 'Criar pagamento recorrente',
+                        },
+                        {
+                            name: 'Listar',
+                            value: 'list',
+                            description: 'Listar pagamentos recorrentes',
+                            action: 'Listar pagamentos recorrentes',
+                        },
+                        {
+                            name: 'Cancelar',
+                            value: 'cancel',
+                            description: 'Cancelar um pagamento recorrente',
+                            action: 'Cancelar pagamento recorrente',
+                        },
+                        {
+                            name: 'Consultar',
+                            value: 'get',
+                            description: 'Consultar um pagamento recorrente',
+                            action: 'Consultar pagamento recorrente',
+                        },
+                    ],
+                    default: 'create',
+                },
+                // Recurring Payment Fields
+                {
+                    displayName: 'ID do Plano',
+                    name: 'planId',
+                    type: 'string',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['recurringPayments'],
+                            operation: ['create'],
+                        },
+                    },
+                    default: '',
+                    description: 'ID do plano de pagamento recorrente',
+                },
+                {
+                    displayName: 'ID do Cliente',
+                    name: 'customerId',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            resource: ['recurringPayments'],
+                            operation: ['create', 'list', 'get'],
+                        },
+                    },
+                    default: '',
+                    description: 'ID do cliente (filtro opcional)',
+                },
+                {
+                    displayName: 'ID do Pagamento Recorrente',
+                    name: 'recurringPaymentId',
+                    type: 'string',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['recurringPayments'],
+                            operation: ['get', 'cancel'],
+                        },
+                    },
+                    default: '',
+                    description: 'ID do pagamento recorrente',
+                },
+                // Webhook Operations
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['webhooks'],
+                        },
+                    },
+                    options: [
+                        {
+                            name: 'Registrar',
+                            value: 'register',
+                            description: 'Registrar um novo webhook',
+                            action: 'Registrar webhook',
+                        },
+                        {
+                            name: 'Listar',
+                            value: 'list',
+                            description: 'Listar webhooks',
+                            action: 'Listar webhooks',
+                        },
+                        {
+                            name: 'Excluir',
+                            value: 'delete',
+                            description: 'Excluir um webhook',
+                            action: 'Excluir webhook',
+                        },
+                        {
+                            name: 'Consultar',
+                            value: 'get',
+                            description: 'Consultar um webhook',
+                            action: 'Consultar webhook',
+                        },
+                    ],
+                    default: 'register',
+                },
+                // Webhook Fields
+                {
+                    displayName: 'URL',
+                    name: 'url',
+                    type: 'string',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['webhooks'],
+                            operation: ['register'],
+                        },
+                    },
+                    default: '',
+                    description: 'URL que receberá as notificações do webhook',
+                },
+                {
+                    displayName: 'Eventos',
+                    name: 'events',
+                    type: 'multiOptions',
+                    displayOptions: {
+                        show: {
+                            resource: ['webhooks'],
+                            operation: ['register'],
+                        },
+                    },
+                    options: [
+                        {
+                            name: 'payment.created',
+                            value: 'payment',
+                        },
+                        {
+                            name: 'payment.updated',
+                            value: 'payment',
+                        },
+                        {
+                            name: 'subscription.created',
+                            value: 'subscription',
+                        },
+                        {
+                            name: 'subscription.updated',
+                            value: 'subscription',
+                        },
+                    ],
+                    default: ['payment'],
+                    description: 'Eventos para os quais o webhook será notificado',
+                },
+                {
+                    displayName: 'Descrição',
+                    name: 'description',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            resource: ['webhooks'],
+                            operation: ['register'],
+                        },
+                    },
+                    default: '',
+                    description: 'Descrição do webhook',
+                },
+                {
+                    displayName: 'ID do Webhook',
+                    name: 'webhookId',
+                    type: 'string',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['webhooks'],
+                            operation: ['get', 'delete'],
+                        },
+                    },
+                    default: '',
+                    description: 'ID do webhook',
+                },
+            ],
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        const credentials = (await this.getCredentials('pixPaymentApi'));
+        const baseUrl = (0, helpers_1.getBaseUrl)(credentials.environment);
+        for (let i = 0; i < items.length; i++) {
+            try {
+                const resource = this.getNodeParameter('resource', i);
+                const operation = this.getNodeParameter('operation', i);
+                let responseData;
+                switch (resource) {
+                    case 'pix':
+                        responseData = await PixPayment.handlePixOperation(this, operation, i, baseUrl, credentials);
+                        break;
+                    case 'subscriptions':
+                        responseData = await PixPayment.handleSubscriptionOperation(this, operation, i, baseUrl, credentials);
+                        break;
+                    case 'recurringPayments':
+                        responseData = await PixPayment.handleRecurringPaymentOperation(this, operation, i, baseUrl, credentials);
+                        break;
+                    case 'webhooks':
+                        responseData = await PixPayment.handleWebhookOperation(this, operation, i, baseUrl, credentials);
+                        break;
+                    default:
+                        throw new Error(`Resource "${resource}" não é suportado`);
+                }
+                returnData.push({
+                    json: PixPayment.normalizeResponse(responseData, resource),
+                });
+            }
+            catch (error) {
+                const errorData = (0, helpers_1.handleMercadoPagoError)(error);
+                if (this.continueOnFail()) {
+                    returnData.push({
+                        json: {
+                            error: errorData.message,
+                            status: errorData.status,
+                            details: errorData,
+                        },
+                    });
+                }
+                else {
+                    throw new Error(errorData.message);
+                }
+            }
+        }
+        return [returnData];
+    }
+    static async handlePixOperation(executeFunctions, operation, itemIndex, baseUrl, credentials) {
+        switch (operation) {
+            case 'create':
+                return await PixPayment.createPixPayment(executeFunctions, itemIndex, baseUrl, credentials);
+            case 'get':
+                return await PixPayment.getPixPayment(executeFunctions, itemIndex, baseUrl, credentials);
+            case 'refund':
+                return await PixPayment.refundPixPayment(executeFunctions, itemIndex, baseUrl, credentials);
+            default:
+                throw new Error(`Operação PIX "${operation}" não é suportada`);
+        }
+    }
+    static async createPixPayment(executeFunctions, itemIndex, baseUrl, credentials) {
+        const amount = executeFunctions.getNodeParameter('amount', itemIndex);
+        const description = executeFunctions.getNodeParameter('description', itemIndex);
+        const payerEmail = executeFunctions.getNodeParameter('payerEmail', itemIndex);
+        const payerDocument = executeFunctions.getNodeParameter('payerDocument', itemIndex);
+        const payerName = executeFunctions.getNodeParameter('payerName', itemIndex);
+        const expirationDate = executeFunctions.getNodeParameter('expirationDate', itemIndex);
+        const externalReference = executeFunctions.getNodeParameter('externalReference', itemIndex);
+        const idempotencyKey = executeFunctions.getNodeParameter('idempotencyKey', itemIndex);
+        // Validações
+        if (!(0, helpers_1.validateEmail)(payerEmail)) {
+            throw new Error('E-mail do pagador inválido');
+        }
+        if (amount <= 0) {
+            throw new Error('Valor do pagamento deve ser maior que zero');
+        }
+        const body = {
+            transaction_amount: (0, helpers_1.normalizeAmount)(amount),
+            description,
+            payment_method_id: 'pix',
+            payer: {
+                email: payerEmail,
+            },
+        };
+        if (payerDocument) {
+            const docType = (0, helpers_1.getDocumentType)(payerDocument);
+            if (!docType) {
+                throw new Error('CPF/CNPJ inválido. Deve conter 11 ou 14 dígitos numéricos');
+            }
+            body.payer.identification = {
+                type: docType,
+                number: (0, helpers_1.cleanDocument)(payerDocument),
+            };
+        }
+        if (payerName) {
+            const nameParts = payerName.trim().split(' ');
+            body.payer.first_name = nameParts[0] || '';
+            body.payer.last_name = nameParts.slice(1).join(' ') || '';
+        }
+        if (expirationDate) {
+            body.date_of_expiration = new Date(expirationDate).toISOString();
+        }
+        if (externalReference) {
+            body.external_reference = externalReference;
+        }
+        const headers = {
+            Authorization: `Bearer ${credentials.accessToken}`,
+            'Content-Type': 'application/json',
+        };
+        if (idempotencyKey) {
+            headers['X-Idempotency-Key'] = idempotencyKey;
+        }
+        const response = await executeFunctions.helpers.requestWithAuthentication.call(executeFunctions, 'pixPaymentApi', {
+            method: 'POST',
+            url: `${baseUrl}/v1/payments`,
+            body,
+            headers,
+            json: true,
+        });
+        return response;
+    }
+    static async getPixPayment(executeFunctions, itemIndex, baseUrl, credentials) {
+        const paymentId = executeFunctions.getNodeParameter('paymentId', itemIndex);
+        if (!paymentId) {
+            throw new Error('ID do pagamento é obrigatório');
+        }
+        const response = await executeFunctions.helpers.requestWithAuthentication.call(executeFunctions, 'pixPaymentApi', {
+            method: 'GET',
+            url: `${baseUrl}/v1/payments/${paymentId}`,
+            headers: {
+                Authorization: `Bearer ${credentials.accessToken}`,
+            },
+            json: true,
+        });
+        return response;
+    }
+    static async refundPixPayment(executeFunctions, itemIndex, baseUrl, credentials) {
+        const paymentId = executeFunctions.getNodeParameter('paymentId', itemIndex);
+        const refundAmount = executeFunctions.getNodeParameter('refundAmount', itemIndex);
+        if (!paymentId) {
+            throw new Error('ID do pagamento é obrigatório');
+        }
+        const body = {};
+        if (refundAmount && refundAmount > 0) {
+            body.amount = (0, helpers_1.normalizeAmount)(refundAmount);
+        }
+        const response = await executeFunctions.helpers.requestWithAuthentication.call(executeFunctions, 'pixPaymentApi', {
+            method: 'POST',
+            url: `${baseUrl}/v1/payments/${paymentId}/refunds`,
+            body: Object.keys(body).length > 0 ? body : undefined,
+            headers: {
+                Authorization: `Bearer ${credentials.accessToken}`,
+                'Content-Type': 'application/json',
+            },
+            json: true,
+        });
+        return response;
+    }
+    static async handleSubscriptionOperation(executeFunctions, operation, itemIndex, baseUrl, credentials) {
+        switch (operation) {
+            case 'create':
+                return await PixPayment.createSubscription(executeFunctions, itemIndex, baseUrl, credentials);
+            case 'get':
+                return await PixPayment.getSubscription(executeFunctions, itemIndex, baseUrl, credentials);
+            case 'pause':
+                return await PixPayment.pauseSubscription(executeFunctions, itemIndex, baseUrl, credentials);
+            case 'resume':
+                return await PixPayment.resumeSubscription(executeFunctions, itemIndex, baseUrl, credentials);
+            case 'cancel':
+                return await PixPayment.cancelSubscription(executeFunctions, itemIndex, baseUrl, credentials);
+            case 'list':
+                return await PixPayment.listSubscriptions(executeFunctions, itemIndex, baseUrl, credentials);
+            default:
+                throw new Error(`Operação de assinatura "${operation}" não é suportada`);
+        }
+    }
+    static async createSubscription(executeFunctions, itemIndex, baseUrl, credentials) {
+        const planId = executeFunctions.getNodeParameter('planId', itemIndex);
+        const payerEmail = executeFunctions.getNodeParameter('payerEmail', itemIndex);
+        const payerDocument = executeFunctions.getNodeParameter('payerDocument', itemIndex);
+        const startDate = executeFunctions.getNodeParameter('startDate', itemIndex);
+        const trialPeriodDays = executeFunctions.getNodeParameter('trialPeriodDays', itemIndex);
+        if (!(0, helpers_1.validateEmail)(payerEmail)) {
+            throw new Error('E-mail do pagador inválido');
+        }
+        const body = {
+            preapproval_plan_id: planId,
+            payer_email: payerEmail,
+        };
+        if (payerDocument) {
+            const docType = (0, helpers_1.getDocumentType)(payerDocument);
+            if (!docType) {
+                throw new Error('CPF/CNPJ inválido');
+            }
+            body.payer = {
+                identification: {
+                    type: docType,
+                    number: (0, helpers_1.cleanDocument)(payerDocument),
+                },
+            };
+        }
+        if (startDate) {
+            body.start_date = new Date(startDate).toISOString();
+        }
+        if (trialPeriodDays && trialPeriodDays > 0) {
+            body.trial_period_days = trialPeriodDays;
+        }
+        const response = await executeFunctions.helpers.requestWithAuthentication.call(executeFunctions, 'pixPaymentApi', {
+            method: 'POST',
+            url: `${baseUrl}/preapproval`,
+            body,
+            headers: {
+                Authorization: `Bearer ${credentials.accessToken}`,
+                'Content-Type': 'application/json',
+            },
+            json: true,
+        });
+        return response;
+    }
+    static async getSubscription(executeFunctions, itemIndex, baseUrl, credentials) {
+        const subscriptionId = executeFunctions.getNodeParameter('subscriptionId', itemIndex);
+        const response = await executeFunctions.helpers.requestWithAuthentication.call(executeFunctions, 'pixPaymentApi', {
+            method: 'GET',
+            url: `${baseUrl}/preapproval/${subscriptionId}`,
+            headers: {
+                Authorization: `Bearer ${credentials.accessToken}`,
+            },
+            json: true,
+        });
+        return response;
+    }
+    static async pauseSubscription(executeFunctions, itemIndex, baseUrl, credentials) {
+        const subscriptionId = executeFunctions.getNodeParameter('subscriptionId', itemIndex);
+        const response = await executeFunctions.helpers.requestWithAuthentication.call(executeFunctions, 'pixPaymentApi', {
+            method: 'PUT',
+            url: `${baseUrl}/preapproval/${subscriptionId}`,
+            body: {
+                status: 'paused',
+            },
+            headers: {
+                Authorization: `Bearer ${credentials.accessToken}`,
+                'Content-Type': 'application/json',
+            },
+            json: true,
+        });
+        return response;
+    }
+    static async resumeSubscription(executeFunctions, itemIndex, baseUrl, credentials) {
+        const subscriptionId = executeFunctions.getNodeParameter('subscriptionId', itemIndex);
+        const response = await executeFunctions.helpers.requestWithAuthentication.call(executeFunctions, 'pixPaymentApi', {
+            method: 'PUT',
+            url: `${baseUrl}/preapproval/${subscriptionId}`,
+            body: {
+                status: 'authorized',
+            },
+            headers: {
+                Authorization: `Bearer ${credentials.accessToken}`,
+                'Content-Type': 'application/json',
+            },
+            json: true,
+        });
+        return response;
+    }
+    static async cancelSubscription(executeFunctions, itemIndex, baseUrl, credentials) {
+        const subscriptionId = executeFunctions.getNodeParameter('subscriptionId', itemIndex);
+        const response = await executeFunctions.helpers.requestWithAuthentication.call(executeFunctions, 'pixPaymentApi', {
+            method: 'PUT',
+            url: `${baseUrl}/preapproval/${subscriptionId}`,
+            body: {
+                status: 'cancelled',
+            },
+            headers: {
+                Authorization: `Bearer ${credentials.accessToken}`,
+                'Content-Type': 'application/json',
+            },
+            json: true,
+        });
+        return response;
+    }
+    static async listSubscriptions(executeFunctions, _itemIndex, baseUrl, credentials) {
+        const response = await executeFunctions.helpers.requestWithAuthentication.call(executeFunctions, 'pixPaymentApi', {
+            method: 'GET',
+            url: `${baseUrl}/preapproval/search`,
+            headers: {
+                Authorization: `Bearer ${credentials.accessToken}`,
+            },
+            json: true,
+        });
+        return response;
+    }
+    static async handleRecurringPaymentOperation(executeFunctions, operation, itemIndex, baseUrl, credentials) {
+        switch (operation) {
+            case 'create':
+                return await PixPayment.createRecurringPayment(executeFunctions, itemIndex, baseUrl, credentials);
+            case 'get':
+                return await PixPayment.getRecurringPayment(executeFunctions, itemIndex, baseUrl, credentials);
+            case 'list':
+                return await PixPayment.listRecurringPayments(executeFunctions, itemIndex, baseUrl, credentials);
+            case 'cancel':
+                return await PixPayment.cancelRecurringPayment(executeFunctions, itemIndex, baseUrl, credentials);
+            default:
+                throw new Error(`Operação de pagamento recorrente "${operation}" não é suportada`);
+        }
+    }
+    static async createRecurringPayment(executeFunctions, itemIndex, baseUrl, credentials) {
+        const planId = executeFunctions.getNodeParameter('planId', itemIndex);
+        // Para pagamentos recorrentes, geralmente criamos via assinatura
+        // Esta é uma implementação simplificada
+        const response = await executeFunctions.helpers.requestWithAuthentication.call(executeFunctions, 'pixPaymentApi', {
+            method: 'GET',
+            url: `${baseUrl}/preapproval/${planId}`,
+            headers: {
+                Authorization: `Bearer ${credentials.accessToken}`,
+            },
+            json: true,
+        });
+        return response;
+    }
+    static async getRecurringPayment(executeFunctions, itemIndex, baseUrl, credentials) {
+        const recurringPaymentId = executeFunctions.getNodeParameter('recurringPaymentId', itemIndex);
+        const response = await executeFunctions.helpers.requestWithAuthentication.call(executeFunctions, 'pixPaymentApi', {
+            method: 'GET',
+            url: `${baseUrl}/preapproval/${recurringPaymentId}`,
+            headers: {
+                Authorization: `Bearer ${credentials.accessToken}`,
+            },
+            json: true,
+        });
+        return response;
+    }
+    static async listRecurringPayments(executeFunctions, itemIndex, baseUrl, credentials) {
+        const customerId = executeFunctions.getNodeParameter('customerId', itemIndex);
+        let url = `${baseUrl}/preapproval/search`;
+        if (customerId) {
+            url += `?payer_id=${customerId}`;
+        }
+        const response = await executeFunctions.helpers.requestWithAuthentication.call(executeFunctions, 'pixPaymentApi', {
+            method: 'GET',
+            url,
+            headers: {
+                Authorization: `Bearer ${credentials.accessToken}`,
+            },
+            json: true,
+        });
+        return response;
+    }
+    static async cancelRecurringPayment(executeFunctions, itemIndex, baseUrl, credentials) {
+        const recurringPaymentId = executeFunctions.getNodeParameter('recurringPaymentId', itemIndex);
+        const response = await executeFunctions.helpers.requestWithAuthentication.call(executeFunctions, 'pixPaymentApi', {
+            method: 'PUT',
+            url: `${baseUrl}/preapproval/${recurringPaymentId}`,
+            body: {
+                status: 'cancelled',
+            },
+            headers: {
+                Authorization: `Bearer ${credentials.accessToken}`,
+                'Content-Type': 'application/json',
+            },
+            json: true,
+        });
+        return response;
+    }
+    static async handleWebhookOperation(executeFunctions, operation, itemIndex, baseUrl, credentials) {
+        switch (operation) {
+            case 'register':
+                return await PixPayment.registerWebhook(executeFunctions, itemIndex, baseUrl, credentials);
+            case 'get':
+                return await PixPayment.getWebhook(executeFunctions, itemIndex, baseUrl, credentials);
+            case 'list':
+                return await PixPayment.listWebhooks(executeFunctions, itemIndex, baseUrl, credentials);
+            case 'delete':
+                return await PixPayment.deleteWebhook(executeFunctions, itemIndex, baseUrl, credentials);
+            default:
+                throw new Error(`Operação de webhook "${operation}" não é suportada`);
+        }
+    }
+    static async registerWebhook(executeFunctions, itemIndex, baseUrl, credentials) {
+        const url = executeFunctions.getNodeParameter('url', itemIndex);
+        const events = executeFunctions.getNodeParameter('events', itemIndex);
+        const description = executeFunctions.getNodeParameter('description', itemIndex);
+        if (!url || !url.startsWith('http')) {
+            throw new Error('URL do webhook deve ser uma URL válida (http:// ou https://)');
+        }
+        const body = {
+            url,
+            events: events.length > 0 ? events : ['payment'],
+        };
+        if (description) {
+            body.description = description;
+        }
+        const response = await executeFunctions.helpers.requestWithAuthentication.call(executeFunctions, 'pixPaymentApi', {
+            method: 'POST',
+            url: `${baseUrl}/v1/webhooks`,
+            body,
+            headers: {
+                Authorization: `Bearer ${credentials.accessToken}`,
+                'Content-Type': 'application/json',
+            },
+            json: true,
+        });
+        return response;
+    }
+    static async getWebhook(executeFunctions, itemIndex, baseUrl, credentials) {
+        const webhookId = executeFunctions.getNodeParameter('webhookId', itemIndex);
+        const response = await executeFunctions.helpers.requestWithAuthentication.call(executeFunctions, 'pixPaymentApi', {
+            method: 'GET',
+            url: `${baseUrl}/v1/webhooks/${webhookId}`,
+            headers: {
+                Authorization: `Bearer ${credentials.accessToken}`,
+            },
+            json: true,
+        });
+        return response;
+    }
+    static async listWebhooks(executeFunctions, _itemIndex, baseUrl, credentials) {
+        const response = await executeFunctions.helpers.requestWithAuthentication.call(executeFunctions, 'pixPaymentApi', {
+            method: 'GET',
+            url: `${baseUrl}/v1/webhooks`,
+            headers: {
+                Authorization: `Bearer ${credentials.accessToken}`,
+            },
+            json: true,
+        });
+        return response;
+    }
+    static async deleteWebhook(executeFunctions, itemIndex, baseUrl, credentials) {
+        const webhookId = executeFunctions.getNodeParameter('webhookId', itemIndex);
+        const response = await executeFunctions.helpers.requestWithAuthentication.call(executeFunctions, 'pixPaymentApi', {
+            method: 'DELETE',
+            url: `${baseUrl}/v1/webhooks/${webhookId}`,
+            headers: {
+                Authorization: `Bearer ${credentials.accessToken}`,
+            },
+            json: true,
+        });
+        return response;
+    }
+    static normalizeResponse(data, resource) {
+        const normalized = {
+            id: data.id || '',
+            status: data.status || '',
+            createdAt: data.date_created || data.created_at || new Date().toISOString(),
+            raw: data,
+        };
+        // Normalização específica por recurso
+        switch (resource) {
+            case 'pix':
+                normalized.amount = data.transaction_amount ? data.transaction_amount / 100 : undefined;
+                normalized.currency = data.currency_id || 'BRL';
+                normalized.qrCode = data.point_of_interaction?.transaction_data?.qr_code;
+                normalized.qrCodeBase64 = data.point_of_interaction?.transaction_data?.qr_code_base64;
+                normalized.description = data.description;
+                normalized.payerEmail = data.payer?.email;
+                break;
+            case 'subscriptions':
+                normalized.planId = data.preapproval_plan_id;
+                normalized.payerEmail = data.payer_email;
+                normalized.startDate = data.start_date;
+                normalized.endDate = data.end_date;
+                normalized.statusDetail = data.status_detail;
+                break;
+            case 'recurringPayments':
+                normalized.planId = data.preapproval_plan_id;
+                normalized.payerEmail = data.payer_email;
+                normalized.nextBillingDate = data.next_billing_date;
+                break;
+            case 'webhooks':
+                normalized.url = data.url;
+                normalized.events = data.events || [];
+                normalized.description = data.description;
+                break;
+        }
+        return normalized;
+    }
+}
+exports.PixPayment = PixPayment;