@treeunfe/nfse 1.0.5

package/dist/index.cjs

@@ -0,0 +1,1563 @@
+'use strict';
+
+var types = require('@treeunfe/types');
+var shared = require('@treeunfe/shared');
+var buffer = require('buffer');
+var zlib = require('zlib');
+var fs = require('fs');
+var path = require('path');
+
+class NFSeAutorizacao {
+    constructor(nfseAutorizacaoService) {
+        this.nfseAutorizacaoService = nfseAutorizacaoService;
+    }
+    async Exec(data) {
+        return await this.nfseAutorizacaoService.Exec(data);
+    }
+}
+
+class NFSeConsulta {
+    constructor(nfseConsultaService) {
+        this.nfseConsultaService = nfseConsultaService;
+    }
+    async Exec(data) {
+        return await this.nfseConsultaService.Exec(data);
+    }
+    async ConsultaDPS(data) {
+        return await this.nfseConsultaService.ConsultaDPS(data);
+    }
+}
+
+class NFSeDistribuicao {
+    constructor(nfseDistribuicaoService) {
+        this.nfseDistribuicaoService = nfseDistribuicaoService;
+    }
+    async DistribuicaoPorNSU(data) {
+        return await this.nfseDistribuicaoService.DistribuicaoPorNSU(data);
+    }
+    async EventosPorChave(data) {
+        return await this.nfseDistribuicaoService.EventosPorChave(data);
+    }
+}
+
+class NFSeEventos {
+    constructor(nfseEventosService) {
+        this.nfseEventosService = nfseEventosService;
+    }
+    async RegistrarEvento(data) {
+        return await this.nfseEventosService.RegistrarEvento(data);
+    }
+    async ConsultarEvento(data) {
+        return await this.nfseEventosService.ConsultarEvento(data);
+    }
+}
+
+class NFSeParametrosMunicipais {
+    constructor(nfseParametrosMunicipaisService) {
+        this.nfseParametrosMunicipaisService = nfseParametrosMunicipaisService;
+    }
+    async ConsultarAliquota(data) {
+        return await this.nfseParametrosMunicipaisService.ConsultarAliquota(data);
+    }
+    async ConsultarHistoricoAliquotas(data) {
+        return await this.nfseParametrosMunicipaisService.ConsultarHistoricoAliquotas(data);
+    }
+    async ConsultarBeneficio(data) {
+        return await this.nfseParametrosMunicipaisService.ConsultarBeneficio(data);
+    }
+    async ConsultarConvenio(data) {
+        return await this.nfseParametrosMunicipaisService.ConsultarConvenio(data);
+    }
+    async ConsultarRegimesEspeciais(data) {
+        return await this.nfseParametrosMunicipaisService.ConsultarRegimesEspeciais(data);
+    }
+    async AlterarBeneficioMunicipal(data) {
+        return await this.nfseParametrosMunicipaisService.AlterarBeneficioMunicipal(data);
+    }
+    async AlterarRetencoes(data) {
+        return await this.nfseParametrosMunicipaisService.AlterarRetencoes(data);
+    }
+}
+
+class NFSeDanfe {
+    constructor(nfseDanfeService) {
+        this.nfseDanfeService = nfseDanfeService;
+    }
+    async GerarDanfe(data) {
+        return await this.nfseDanfeService.GerarDanfe(data);
+    }
+}
+
+/*
+ * This file is part of Treeunfe DFe.
+ *
+ * Treeunfe DFe is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Treeunfe DFe is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Treeunfe DFe. If not, see <https://www.gnu.org/licenses/>.
+ */
+class NFSeAutorizacaoService extends shared.BaseNFSe {
+    constructor(environment, utility, xmlBuilder, axios, saveFiles, gerarConsulta) {
+        super(environment, utility, xmlBuilder, 'NFSe_Autorizacao', axios, saveFiles, gerarConsulta);
+        this.dpsXmlGZipB64 = '';
+    }
+    /**
+     * Gera o ID do DPS conforme regra do schema:
+     * "DPS" + Cód.Mun (7) + Tipo de Inscrição Federal (1) + Inscrição Federal (14) + Série DPS (5) + Núm. DPS (15)
+     * Total: 45 caracteres
+     *
+     * Tipo de Inscrição: 1 = CNPJ, 2 = CPF
+     */
+    gerarIdDPS(dps) {
+        // Código do município (7 dígitos)
+        const cLocEmi = dps.infDps.cLocEmi.replace(/\D/g, '').padStart(7, '0').substring(0, 7);
+        // Tipo de inscrição e número
+        // IMPORTANTE: tpInscFed: 1 = CPF, 2 = CNPJ (invertido do que parece lógico!)
+        const prestador = dps.infDps.prest;
+        let tipoInscricao;
+        let inscricaoFederal;
+        if (prestador.CNPJ) {
+            tipoInscricao = '2'; // CNPJ = 2
+            inscricaoFederal = prestador.CNPJ.replace(/\D/g, '').padStart(14, '0').substring(0, 14);
+        }
+        else if (prestador.CPF) {
+            tipoInscricao = '1'; // CPF = 1
+            inscricaoFederal = prestador.CPF.replace(/\D/g, '').padStart(14, '0').substring(0, 14);
+        }
+        else {
+            // Fallback: assume CNPJ se não houver nenhum
+            tipoInscricao = '2';
+            inscricaoFederal = '0'.repeat(14);
+        }
+        // Série DPS (5 dígitos) - apenas números, se houver letras, converte para números
+        // O schema permite até 5 dígitos, mas o ID precisa ter exatamente 5 dígitos com zeros à esquerda
+        const serieOriginal = dps.infDps.serie.replace(/\D/g, '');
+        const serie = serieOriginal.padStart(5, '0').substring(0, 5);
+        // Número DPS (15 dígitos)
+        // IMPORTANTE: O schema TSNumDPS não permite números que começam com zero (pattern: [1-9]{1}[0-9]{0,14})
+        // Mas o ID precisa ter exatamente 15 dígitos. O servidor faz o padding ao validar.
+        // Usamos o valor original sem padding para o XML, mas com padding para o ID
+        const nDPSOriginal = dps.infDps.nDPS.replace(/\D/g, '');
+        // Garante que não comece com zero (conforme schema) e depois adiciona zeros à esquerda para o ID
+        const nDPS = nDPSOriginal.padStart(15, '0').substring(0, 15);
+        const idDPS = `DPS${cLocEmi}${tipoInscricao}${inscricaoFederal}${serie}${nDPS}`;
+        // Log detalhado para debug
+        shared.logger.info('Gerando ID do DPS', {
+            context: 'NFSeAutorizacaoService',
+            valores: {
+                cLocEmi: dps.infDps.cLocEmi,
+                cLocEmiFormatado: cLocEmi,
+                tipoInscricao,
+                inscricaoFederal,
+                serieOriginal: dps.infDps.serie,
+                serieFormatada: serie,
+                nDPSOriginal: dps.infDps.nDPS,
+                nDPSFormatado: nDPS,
+                idDPS,
+                tamanho: idDPS.length
+            }
+        });
+        // Validação: deve ter exatamente 45 caracteres
+        if (idDPS.length !== 45) {
+            throw new Error(`ID do DPS deve ter 45 caracteres, mas tem ${idDPS.length}: ${idDPS}`);
+        }
+        return idDPS;
+    }
+    /**
+     * Monta o XML do DPS a partir do objeto JSON
+     */
+    gerarXmlDPS(dps) {
+        const config = this.environment.getConfig();
+        const ambiente = config.ambiente || 2;
+        // Gera o ID do DPS se não foi fornecido
+        const idDPS = dps.infDps.Id || this.gerarIdDPS(dps);
+        // Garante que o ambiente está correto e remove Id do objeto (será colocado como atributo)
+        const { Id, ...infDpsDataSemId } = dps.infDps;
+        const infDpsData = {
+            ...infDpsDataSemId,
+            tpAmb: ambiente
+        };
+        // Monta o objeto XML com a estrutura correta
+        // O atributo Id deve estar no $ do infDPS (maiúsculas conforme schema)
+        // Garantimos que $ seja definido por último para não ser sobrescrito
+        const infDPSObject = {
+            ...infDpsData
+        };
+        infDPSObject.$ = {
+            Id: idDPS
+        };
+        const dpsObject = {
+            $: {
+                versao: '1.01',
+                xmlns: 'http://www.sped.fazenda.gov.br/nfse'
+            },
+            infDPS: infDPSObject // Nome exato conforme schema: infDPS (maiúsculas)
+        };
+        // Gera o XML
+        let xml = this.xmlBuilder.gerarXml(dpsObject, 'DPS', this.metodo);
+        // Verifica se o atributo Id está presente no XML gerado
+        const temIdNoXml = xml.includes(`Id="${idDPS}"`) || xml.includes(`Id='${idDPS}'`);
+        // Adiciona a declaração XML com encoding UTF-8 se não existir
+        if (!xml.trim().startsWith('<?xml')) {
+            xml = '<?xml version="1.0" encoding="UTF-8"?>\n' + xml;
+        }
+        else {
+            // Garante que a declaração tenha encoding UTF-8
+            xml = xml.replace(/^<\?xml[^>]*\?>/, '<?xml version="1.0" encoding="UTF-8"?>');
+        }
+        shared.logger.info('XML do DPS gerado', {
+            context: 'NFSeAutorizacaoService',
+            idDPS,
+            tamanho: xml.length,
+            comDeclaracao: xml.trim().startsWith('<?xml'),
+            temIdNoXml,
+            xmlPreview: xml.substring(0, 300)
+        });
+        if (!temIdNoXml) {
+            shared.logger.warn('Atributo Id não encontrado no XML gerado (antes da assinatura)', {
+                context: 'NFSeAutorizacaoService',
+                idDPS,
+                xmlPreview: xml.substring(0, 500)
+            });
+        }
+        // Assina o XML (usa o nome exato do elemento conforme schema)
+        let xmlAssinado = this.xmlBuilder.assinarXML(xml, 'infDPS');
+        // Garante que o XML assinado tenha a declaração UTF-8
+        if (!xmlAssinado.trim().startsWith('<?xml')) {
+            xmlAssinado = '<?xml version="1.0" encoding="UTF-8"?>\n' + xmlAssinado;
+        }
+        else {
+            // Garante que a declaração tenha encoding UTF-8
+            xmlAssinado = xmlAssinado.replace(/^<\?xml[^>]*\?>/, '<?xml version="1.0" encoding="UTF-8"?>');
+        }
+        // Verifica se o atributo Id está presente no XML
+        const temId = xmlAssinado.includes(`Id="${idDPS}"`) || xmlAssinado.includes(`Id='${idDPS}'`);
+        shared.logger.info('XML do DPS assinado', {
+            context: 'NFSeAutorizacaoService',
+            tamanho: xmlAssinado.length,
+            comDeclaracao: xmlAssinado.trim().startsWith('<?xml'),
+            declaracao: xmlAssinado.substring(0, 50),
+            temId,
+            idDPS
+        });
+        if (!temId) {
+            shared.logger.warn('Atributo Id não encontrado no XML assinado', {
+                context: 'NFSeAutorizacaoService',
+                idDPS,
+                xmlPreview: xmlAssinado.substring(0, 500)
+            });
+        }
+        return xmlAssinado;
+    }
+    /**
+     * Processa o DPS: monta XML, assina, compacta e codifica
+     */
+    processarDPS(data) {
+        // Se já foi fornecido o Base64, usa diretamente
+        if (data.dpsXmlGZipB64) {
+            return data.dpsXmlGZipB64;
+        }
+        // Se foi fornecido o JSON, processa
+        if (data.DPS) {
+            const dpsArray = Array.isArray(data.DPS) ? data.DPS : [data.DPS];
+            const xmls = [];
+            for (const dps of dpsArray) {
+                // Monta e assina o XML
+                const xml = this.gerarXmlDPS(dps);
+                // Compacta em GZip
+                const gzip = zlib.gzipSync(buffer.Buffer.from(xml, 'utf-8'));
+                // Codifica em Base64
+                const base64 = gzip.toString('base64');
+                xmls.push(base64);
+            }
+            // Se houver apenas um DPS, retorna o Base64 diretamente
+            // Se houver múltiplos, precisaria de um lote (por enquanto, retorna o primeiro)
+            return xmls[0];
+        }
+        throw new Error('É necessário fornecer DPS (JSON) ou dpsXmlGZipB64 (Base64)');
+    }
+    prepararDados(data) {
+        // Processa o DPS antes de enviar
+        this.dpsXmlGZipB64 = this.processarDPS(data);
+        return {
+            dpsXmlGZipB64: this.dpsXmlGZipB64
+        };
+    }
+    getHttpMethod() {
+        return 'POST';
+    }
+    async Exec(data) {
+        try {
+            const response = await super.Exec(data);
+            let xmls = [];
+            // Se a resposta contém NFSe em base64 gzip, descompacta e parseia
+            if (response.nfseXmlGZipB64) {
+                try {
+                    const nfseBuffer = buffer.Buffer.from(response.nfseXmlGZipB64, 'base64');
+                    const nfseXml = zlib.gunzipSync(nfseBuffer).toString('utf-8');
+                    // Salva o XML da NFSe descompactado
+                    const config = this.environment.getConfig();
+                    if (config.armazenarXMLAutorizacao && response.chaveAcesso) {
+                        this.utility.salvaXML({
+                            data: nfseXml,
+                            fileName: response.chaveAcesso,
+                            metodo: this.metodo,
+                            path: config.pathXMLAutorizacao,
+                        });
+                    }
+                    const json = new shared.XmlParser();
+                    const nfseJson = json.convertXmlToJson(nfseXml, 'NFSeAutorizacao');
+                    xmls.push({
+                        NFSe: nfseJson
+                    });
+                }
+                catch (error) {
+                    // Log como warning ao invés de error, pois a NFSe foi autorizada com sucesso
+                    // O erro é apenas no processamento do XML descompactado, não na autorização
+                    shared.logger.warn('Aviso ao processar XML da NFSe descompactada', {
+                        context: 'NFSeAutorizacaoService',
+                        message: error.message,
+                        note: 'A NFSe foi autorizada com sucesso, mas o XML não pôde ser processado automaticamente'
+                    });
+                }
+            }
+            return {
+                success: true,
+                response,
+                xmls: xmls.length > 0 ? xmls : undefined
+            };
+        }
+        catch (error) {
+            shared.logger.error('Erro na autorização de NFSe', error, {
+                context: 'NFSeAutorizacaoService',
+            });
+            throw error;
+        }
+    }
+}
+
+/*
+ * This file is part of Treeunfe DFe.
+ *
+ * Treeunfe DFe is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Treeunfe DFe is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Treeunfe DFe. If not, see <https://www.gnu.org/licenses/>.
+ */
+class NFSeConsultaService extends shared.BaseNFSe {
+    constructor(environment, utility, xmlBuilder, axios, saveFiles, gerarConsulta) {
+        super(environment, utility, xmlBuilder, 'NFSe_Consulta', axios, saveFiles, gerarConsulta);
+        this.consultaTipo = 'NFSe';
+    }
+    prepararDados(_data) {
+        return null; // GET request não precisa de body
+    }
+    getHttpMethod() {
+        return 'GET';
+    }
+    getUrlPath(data) {
+        if (this.consultaTipo === 'DPS' && data && 'id' in data) {
+            return `/${data.id}`;
+        }
+        if (data && 'chaveAcesso' in data) {
+            return `/${data.chaveAcesso}`;
+        }
+        return '';
+    }
+    getWebServiceUrl() {
+        if (this.consultaTipo === 'DPS') {
+            return this.utility.getWebServiceUrlNFSe('NFSe_ConsultaDPS');
+        }
+        return this.utility.getWebServiceUrlNFSe('NFSe_Consulta');
+    }
+    async Exec(data) {
+        this.consultaTipo = 'NFSe';
+        return await super.Exec(data);
+    }
+    async ConsultaDPS(data) {
+        this.consultaTipo = 'DPS';
+        return await super.Exec(data);
+    }
+}
+
+/*
+ * This file is part of Treeunfe DFe.
+ *
+ * Treeunfe DFe is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Treeunfe DFe is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Treeunfe DFe. If not, see <https://www.gnu.org/licenses/>.
+ */
+class NFSeDistribuicaoService extends shared.BaseNFSe {
+    constructor(environment, utility, xmlBuilder, axios, saveFiles, gerarConsulta) {
+        super(environment, utility, xmlBuilder, 'NFSe_Distribuicao', axios, saveFiles, gerarConsulta);
+    }
+    prepararDados(_data) {
+        return null; // GET request
+    }
+    getHttpMethod() {
+        return 'GET';
+    }
+    getUrlPath(data) {
+        if (data && 'chaveAcesso' in data) {
+            return `/${data.chaveAcesso}/Eventos`;
+        }
+        if (data && 'nsu' in data) {
+            return `/${data.nsu}`;
+        }
+        return '';
+    }
+    getQueryParams(data) {
+        if (data && 'nsu' in data) {
+            const nsuData = data;
+            const params = {};
+            if (nsuData.cnpjConsulta) {
+                params.cnpjConsulta = nsuData.cnpjConsulta;
+            }
+            if (nsuData.lote !== undefined) {
+                params.lote = nsuData.lote;
+            }
+            return params;
+        }
+        return {};
+    }
+    getWebServiceUrl() {
+        if (this.metodo === 'NFSe_EventosPorChave') {
+            return this.utility.getWebServiceUrlNFSe('NFSe_EventosPorChave');
+        }
+        return this.utility.getWebServiceUrlNFSe('NFSe_Distribuicao');
+    }
+    async DistribuicaoPorNSU(data) {
+        const response = await super.Exec(data);
+        // Se a resposta contém documentos, processa e salva cada um
+        if (response.LoteDFe && Array.isArray(response.LoteDFe) && response.LoteDFe.length > 0) {
+            const config = this.environment.getConfig();
+            // Processa cada documento retornado
+            for (const documento of response.LoteDFe) {
+                if (documento.ArquivoXml && documento.ChaveAcesso) {
+                    try {
+                        // O ArquivoXml pode estar em dois formatos:
+                        // 1. Base64 simples → GZip direto
+                        // 2. Base64 duplo → Base64 → GZip
+                        let documentoXml;
+                        try {
+                            // Tenta primeiro: Base64 simples → GZip direto
+                            const documentoBuffer = Buffer.from(documento.ArquivoXml, 'base64');
+                            documentoXml = zlib.gunzipSync(documentoBuffer).toString('utf-8');
+                        }
+                        catch (gzipError) {
+                            // Se falhar, tenta: Base64 duplo → Base64 → GZip
+                            const primeiraDecodificacao = Buffer.from(documento.ArquivoXml, 'base64').toString('utf-8');
+                            const documentoBuffer = Buffer.from(primeiraDecodificacao, 'base64');
+                            documentoXml = zlib.gunzipSync(documentoBuffer).toString('utf-8');
+                        }
+                        // Salva o XML do documento (apenas se estiver configurado)
+                        // Documentos autorizados devem ser salvos em Autorizacao/NFSe/
+                        if (config.armazenarXMLAutorizacao && config.pathXMLAutorizacao) {
+                            let fileName;
+                            let pathCompleto;
+                            if (documento.TipoDocumento === 'EVENTO' && documento.TipoEvento) {
+                                // Evento: salva em subpasta do tipo de evento
+                                const tipoEventoMap = {
+                                    'CANCELAMENTO': 101101,
+                                    'CANCELAMENTO_POR_SUBSTITUICAO': 105102,
+                                    'SOLICITACAO_CANCELAMENTO_ANALISE_FISCAL': 101103,
+                                    'CANCELAMENTO_DEFERIDO_ANALISE_FISCAL': 105104,
+                                    'CANCELAMENTO_INDEFERIDO_ANALISE_FISCAL': 105105,
+                                    'CONFIRMACAO_PRESTADOR': 202201,
+                                    'REJEICAO_PRESTADOR': 202205,
+                                    'CONFIRMACAO_TOMADOR': 203202,
+                                    'REJEICAO_TOMADOR': 203206,
+                                };
+                                let tipoEvento;
+                                if (typeof documento.TipoEvento === 'string') {
+                                    tipoEvento = tipoEventoMap[documento.TipoEvento] || parseInt(documento.TipoEvento, 10) || 101101;
+                                }
+                                else {
+                                    tipoEvento = documento.TipoEvento;
+                                }
+                                const nsu = documento.NSU || 0;
+                                fileName = `${documento.ChaveAcesso}_evento_${tipoEvento}_${nsu}`;
+                                pathCompleto = `${config.pathXMLAutorizacao}/${tipoEvento}`;
+                            }
+                            else if (documento.TipoDocumento === 'NFSE') {
+                                // NFSe: salva na pasta raiz
+                                fileName = documento.ChaveAcesso;
+                                pathCompleto = config.pathXMLAutorizacao;
+                            }
+                            else {
+                                // Outro tipo de documento: salva na pasta raiz com prefixo
+                                const nsu = documento.NSU || 0;
+                                fileName = `${documento.ChaveAcesso}_${documento.TipoDocumento}_${nsu}`;
+                                pathCompleto = config.pathXMLAutorizacao;
+                            }
+                            shared.logger.info('Tentando salvar XML do documento de DistribuicaoPorNSU', {
+                                context: 'NFSeDistribuicaoService',
+                                fileName: fileName,
+                                path: pathCompleto,
+                                tipoDocumento: documento.TipoDocumento,
+                                tipoEvento: documento.TipoEvento,
+                                nsu: documento.NSU
+                            });
+                            this.utility.salvaXML({
+                                data: documentoXml,
+                                fileName: fileName,
+                                metodo: this.metodo,
+                                path: pathCompleto,
+                            });
+                            shared.logger.info('XML do documento de DistribuicaoPorNSU salvo com sucesso', {
+                                context: 'NFSeDistribuicaoService',
+                                fileName: fileName,
+                                path: pathCompleto,
+                                tipoDocumento: documento.TipoDocumento
+                            });
+                        }
+                    }
+                    catch (error) {
+                        shared.logger.error('Erro ao processar XML do documento de DistribuicaoPorNSU', {
+                            context: 'NFSeDistribuicaoService',
+                            message: error.message,
+                            stack: error.stack,
+                            documento: documento
+                        });
+                    }
+                }
+            }
+        }
+        return response;
+    }
+    async EventosPorChave(data) {
+        this.metodo = 'NFSe_EventosPorChave';
+        const response = await super.Exec(data);
+        // Se a resposta contém eventos, processa e salva cada um
+        if (response.LoteDFe && Array.isArray(response.LoteDFe) && response.LoteDFe.length > 0) {
+            const config = this.environment.getConfig();
+            // Processa cada evento retornado
+            for (const evento of response.LoteDFe) {
+                // Apenas processa eventos (TipoDocumento = 'EVENTO' e TipoEvento presente)
+                if (evento.TipoDocumento === 'EVENTO' && evento.TipoEvento) {
+                    if (evento.ArquivoXml) {
+                        try {
+                            // O ArquivoXml pode estar em dois formatos:
+                            // 1. Base64 simples → GZip direto (EventosPorChave)
+                            // 2. Base64 duplo → Base64 → GZip (ConsultarEvento)
+                            let eventoXml;
+                            try {
+                                // Tenta primeiro: Base64 simples → GZip direto
+                                const eventoBuffer = Buffer.from(evento.ArquivoXml, 'base64');
+                                eventoXml = zlib.gunzipSync(eventoBuffer).toString('utf-8');
+                            }
+                            catch (gzipError) {
+                                // Se falhar, tenta: Base64 duplo → Base64 → GZip
+                                const primeiraDecodificacao = Buffer.from(evento.ArquivoXml, 'base64').toString('utf-8');
+                                const eventoBuffer = Buffer.from(primeiraDecodificacao, 'base64');
+                                eventoXml = zlib.gunzipSync(eventoBuffer).toString('utf-8');
+                            }
+                            // Mapeia o TipoEvento de string para número
+                            // O TipoEvento vem como string (ex: "CANCELAMENTO") e precisa ser convertido para número (ex: 101101)
+                            const tipoEventoMap = {
+                                'CANCELAMENTO': 101101,
+                                'CANCELAMENTO_POR_SUBSTITUICAO': 105102,
+                                'SOLICITACAO_CANCELAMENTO_ANALISE_FISCAL': 101103,
+                                'CANCELAMENTO_DEFERIDO_ANALISE_FISCAL': 105104,
+                                'CANCELAMENTO_INDEFERIDO_ANALISE_FISCAL': 105105,
+                                'CONFIRMACAO_PRESTADOR': 202201,
+                                'REJEICAO_PRESTADOR': 202205,
+                                'CONFIRMACAO_TOMADOR': 203202,
+                                'REJEICAO_TOMADOR': 203206,
+                            };
+                            // Tenta converter string para número, ou usa o mapeamento
+                            let tipoEvento;
+                            if (typeof evento.TipoEvento === 'string') {
+                                tipoEvento = tipoEventoMap[evento.TipoEvento] || parseInt(evento.TipoEvento, 10) || 101101;
+                            }
+                            else {
+                                tipoEvento = evento.TipoEvento;
+                            }
+                            // Salva o XML do evento (apenas se estiver configurado)
+                            // Eventos de NFSe autorizada devem ser salvos em Autorizacao/NFSe/{tipoEvento}/
+                            if (config.armazenarXMLAutorizacao && config.pathXMLAutorizacao && evento.ChaveAcesso) {
+                                const nsu = evento.NSU || 0;
+                                const fileName = `${evento.ChaveAcesso}_evento_${tipoEvento}_${nsu}`;
+                                // Cria o path com a subpasta do tipo de evento em Autorizacao/NFSe
+                                const pathComTipoEvento = `${config.pathXMLAutorizacao}/${tipoEvento}`;
+                                shared.logger.info('Tentando salvar XML do evento de EventosPorChave', {
+                                    context: 'NFSeDistribuicaoService',
+                                    fileName: fileName,
+                                    path: pathComTipoEvento,
+                                    tipoEvento: tipoEvento,
+                                    tipoEventoOriginal: evento.TipoEvento,
+                                    nsu: nsu
+                                });
+                                this.utility.salvaXML({
+                                    data: eventoXml,
+                                    fileName: fileName,
+                                    metodo: this.metodo,
+                                    path: pathComTipoEvento,
+                                });
+                                shared.logger.info('XML do evento de EventosPorChave salvo com sucesso', {
+                                    context: 'NFSeDistribuicaoService',
+                                    fileName: fileName,
+                                    path: pathComTipoEvento,
+                                    tipoEvento: tipoEvento
+                                });
+                            }
+                        }
+                        catch (error) {
+                            shared.logger.error('Erro ao processar XML do evento de EventosPorChave', {
+                                context: 'NFSeDistribuicaoService',
+                                message: error.message,
+                                stack: error.stack,
+                                evento: evento
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        return response;
+    }
+}
+
+/*
+ * This file is part of Treeunfe DFe.
+ *
+ * Treeunfe DFe is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Treeunfe DFe is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Treeunfe DFe. If not, see <https://www.gnu.org/licenses/>.
+ */
+class NFSeEventosService extends shared.BaseNFSe {
+    constructor(environment, utility, xmlBuilder, axios, saveFiles, gerarConsulta) {
+        super(environment, utility, xmlBuilder, 'NFSe_Eventos', axios, saveFiles, gerarConsulta);
+        this.pedidoRegistroEventoXmlGZipB64 = '';
+    }
+    /**
+     * Gera o ID do pedido de registro de evento
+     * Formato: "PRE" + Chave de Acesso NFS-e + Tipo do evento + Número do Pedido de Registro do Evento (nPedRegEvento)
+     * Padrão esperado: PRE[0-9]{56} = 59 caracteres total (PRE + 56 dígitos)
+     * Como temos: chave (50) + tipo (6) + nPed (3) = 59 dígitos, mas o padrão espera 56
+     * A chave de acesso deve ser truncada para 47 dígitos: 47 + 6 + 3 = 56 dígitos
+     */
+    gerarIdPedRegEvento(chaveAcesso, tipoEvento, nPedRegEvento) {
+        // Remove todos os caracteres não numéricos da chave de acesso
+        const chaveLimpa = chaveAcesso.replace(/\D/g, '');
+        // O padrão espera PRE + 56 dígitos = 59 caracteres total
+        // Como temos tipo (6) + nPed (3) = 9 dígitos fixos, a chave deve ter 47 dígitos
+        // Trunca a chave para 47 dígitos (pega os primeiros 47)
+        const chave47 = chaveLimpa.substring(0, 47).padStart(47, '0');
+        // Tipo do evento com 6 dígitos
+        const tipoEventoStr = tipoEvento.toString().padStart(6, '0');
+        // Número do pedido com 3 dígitos
+        const nPedRegEventoStr = nPedRegEvento.toString().padStart(3, '0');
+        const id = `PRE${chave47}${tipoEventoStr}${nPedRegEventoStr}`;
+        // Validação: deve ter exatamente 59 caracteres (PRE + 56 dígitos)
+        if (id.length !== 59) {
+            shared.logger.warn(`ID do pedido de registro de evento tem tamanho incorreto: ${id.length} (esperado: 59)`, { context: 'gerarIdPedRegEvento', id });
+        }
+        return id;
+    }
+    /**
+     * Gera o XML do pedido de registro de evento
+     */
+    gerarXmlPedRegEvento(pedRegEvento, chaveAcesso, tipoEvento, nPedRegEvento) {
+        // Gera o ID do pedido
+        const idPedReg = this.gerarIdPedRegEvento(chaveAcesso, tipoEvento, nPedRegEvento);
+        // Monta o objeto XML
+        // IMPORTANTE: A ordem dos elementos deve seguir o schema:
+        // tpAmb, verAplic, dhEvento, (CNPJAutor ou CPFAutor), chNFSe, (evento específico)
+        // Construímos o objeto na ordem correta para garantir que o xml2js respeite a sequência
+        const infPedRegObj = {
+            $: {
+                Id: idPedReg
+            },
+            tpAmb: pedRegEvento.infPedReg.tpAmb,
+            verAplic: pedRegEvento.infPedReg.verAplic,
+            dhEvento: pedRegEvento.infPedReg.dhEvento
+        };
+        // Adiciona CNPJ ou CPF do autor (deve vir ANTES de chNFSe)
+        if (pedRegEvento.infPedReg.CNPJAutor) {
+            infPedRegObj.CNPJAutor = pedRegEvento.infPedReg.CNPJAutor;
+        }
+        else if (pedRegEvento.infPedReg.CPFAutor) {
+            infPedRegObj.CPFAutor = pedRegEvento.infPedReg.CPFAutor;
+        }
+        // Adiciona chNFSe (deve vir DEPOIS de CNPJAutor/CPFAutor)
+        infPedRegObj.chNFSe = pedRegEvento.infPedReg.chNFSe;
+        // Adiciona o evento específico (e101101 para cancelamento)
+        if (pedRegEvento.infPedReg.e101101) {
+            infPedRegObj.e101101 = {
+                xDesc: pedRegEvento.infPedReg.e101101.xDesc,
+                cMotivo: pedRegEvento.infPedReg.e101101.cMotivo,
+                xMotivo: pedRegEvento.infPedReg.e101101.xMotivo
+            };
+        }
+        else if (pedRegEvento.infPedReg.e105102) {
+            infPedRegObj.e105102 = {
+                xDesc: pedRegEvento.infPedReg.e105102.xDesc,
+                chNFSeSubst: pedRegEvento.infPedReg.e105102.chNFSeSubst
+            };
+        }
+        // O xml2js.Builder cria o elemento raiz automaticamente a partir do rootTag
+        // Então passamos apenas o conteúdo interno com os atributos
+        const pedRegEventoObject = {
+            $: {
+                versao: '1.01',
+                xmlns: 'http://www.sped.fazenda.gov.br/nfse'
+            },
+            infPedReg: infPedRegObj
+        };
+        // Gera o XML (o rootTag 'pedRegEvento' será usado como elemento raiz)
+        let xml = this.xmlBuilder.gerarXml(pedRegEventoObject, 'pedRegEvento', this.metodo);
+        // Adiciona a declaração XML com encoding UTF-8 se não existir
+        if (!xml.trim().startsWith('<?xml')) {
+            xml = '<?xml version="1.0" encoding="UTF-8"?>\n' + xml;
+        }
+        else {
+            xml = xml.replace(/^<\?xml[^>]*\?>/, '<?xml version="1.0" encoding="UTF-8"?>');
+        }
+        // Assina o XML
+        let xmlAssinado = this.xmlBuilder.assinarXML(xml, 'infPedReg');
+        // Garante que o XML assinado tenha a declaração UTF-8
+        if (!xmlAssinado.trim().startsWith('<?xml')) {
+            xmlAssinado = '<?xml version="1.0" encoding="UTF-8"?>\n' + xmlAssinado;
+        }
+        else {
+            xmlAssinado = xmlAssinado.replace(/^<\?xml[^>]*\?>/, '<?xml version="1.0" encoding="UTF-8"?>');
+        }
+        return xmlAssinado;
+    }
+    /**
+     * Processa o pedido de registro de evento: monta XML, assina, compacta e codifica
+     */
+    processarPedRegEvento(data, tipoEvento, nPedRegEvento = 1) {
+        // Se já foi fornecido o Base64, usa diretamente
+        if (data.pedidoRegistroEventoXmlGZipB64) {
+            return data.pedidoRegistroEventoXmlGZipB64;
+        }
+        // Se foi fornecido o JSON, processa
+        if (data.pedRegEvento) {
+            const xml = this.gerarXmlPedRegEvento(data.pedRegEvento, data.chaveAcesso, tipoEvento, nPedRegEvento);
+            // Compacta em GZip
+            const xmlGzip = zlib.gzipSync(Buffer.from(xml, 'utf-8'));
+            // Codifica em Base64
+            const xmlGzipB64 = xmlGzip.toString('base64');
+            return xmlGzipB64;
+        }
+        throw new Error('É necessário fornecer pedRegEvento (JSON) ou pedidoRegistroEventoXmlGZipB64 (Base64)');
+    }
+    prepararDados(data) {
+        // Para consulta (GET), não precisa preparar dados
+        if (this.metodo.includes('Consultar') || this.getHttpMethod() === 'GET') {
+            return null;
+        }
+        // Para registro de evento (POST), processa os dados
+        const eventoData = data;
+        // Determina o tipo de evento baseado no pedRegEvento
+        let tipoEvento = types.TipoEventoNFSe.CANCELAMENTO; // Default
+        if (eventoData.pedRegEvento) {
+            if (eventoData.pedRegEvento.infPedReg.e101101) {
+                tipoEvento = types.TipoEventoNFSe.CANCELAMENTO;
+            }
+            else if (eventoData.pedRegEvento.infPedReg.e105102) {
+                tipoEvento = types.TipoEventoNFSe.CANCELAMENTO_POR_SUBSTITUICAO;
+            }
+        }
+        // Processa o pedido de registro de evento antes de enviar
+        this.pedidoRegistroEventoXmlGZipB64 = this.processarPedRegEvento(eventoData, tipoEvento);
+        return {
+            pedidoRegistroEventoXmlGZipB64: this.pedidoRegistroEventoXmlGZipB64
+        };
+    }
+    /**
+     * Método para obter a URL base do webservice
+     * Consulta de evento usa a mesma URL base que registro de evento
+     */
+    getWebServiceUrl() {
+        // Consulta de evento usa a mesma URL base que registro de evento
+        const metodoUrl = this.metodo.includes('Consultar') ? 'NFSe_Eventos' : this.metodo;
+        return this.utility.getWebServiceUrlNFSe(metodoUrl);
+    }
+    getHttpMethod() {
+        if (this.metodo.includes('Consultar')) {
+            return 'GET';
+        }
+        return 'POST';
+    }
+    getUrlPath(data) {
+        if (data && 'tipoEvento' in data && 'numSeqEvento' in data) {
+            const eventoData = data;
+            return `/${eventoData.chaveAcesso}/eventos/${eventoData.tipoEvento}/${eventoData.numSeqEvento}`;
+        }
+        if (data && 'chaveAcesso' in data) {
+            return `/${data.chaveAcesso}/eventos`;
+        }
+        return '';
+    }
+    async RegistrarEvento(data) {
+        const response = await super.Exec(data);
+        // Se a resposta contém evento em base64 gzip, descompacta e salva
+        if (response.eventoXmlGZipB64) {
+            try {
+                const eventoBuffer = Buffer.from(response.eventoXmlGZipB64, 'base64');
+                const eventoXml = zlib.gunzipSync(eventoBuffer).toString('utf-8');
+                // Determina o tipo de evento baseado no pedRegEvento
+                let tipoEvento = types.TipoEventoNFSe.CANCELAMENTO; // Default
+                if (data.pedRegEvento) {
+                    if (data.pedRegEvento.infPedReg.e101101) {
+                        tipoEvento = types.TipoEventoNFSe.CANCELAMENTO;
+                    }
+                    else if (data.pedRegEvento.infPedReg.e105102) {
+                        tipoEvento = types.TipoEventoNFSe.CANCELAMENTO_POR_SUBSTITUICAO;
+                    }
+                    else if (data.pedRegEvento.infPedReg.e101103) {
+                        tipoEvento = types.TipoEventoNFSe.SOLICITACAO_CANCELAMENTO_ANALISE_FISCAL;
+                    }
+                    else if (data.pedRegEvento.infPedReg.e105104) {
+                        tipoEvento = types.TipoEventoNFSe.CANCELAMENTO_DEFERIDO_ANALISE_FISCAL;
+                    }
+                    else if (data.pedRegEvento.infPedReg.e105105) {
+                        tipoEvento = types.TipoEventoNFSe.CANCELAMENTO_INDEFERIDO_ANALISE_FISCAL;
+                    }
+                    else if (data.pedRegEvento.infPedReg.e202201) {
+                        tipoEvento = types.TipoEventoNFSe.CONFIRMACAO_PRESTADOR;
+                    }
+                    else if (data.pedRegEvento.infPedReg.e202205) {
+                        tipoEvento = types.TipoEventoNFSe.REJEICAO_PRESTADOR;
+                    }
+                    else if (data.pedRegEvento.infPedReg.e203202) {
+                        tipoEvento = types.TipoEventoNFSe.CONFIRMACAO_TOMADOR;
+                    }
+                    else if (data.pedRegEvento.infPedReg.e203206) {
+                        tipoEvento = types.TipoEventoNFSe.REJEICAO_TOMADOR;
+                    }
+                }
+                // Salva o XML do evento descompactado
+                const config = this.environment.getConfig();
+                if (config.armazenarXMLAutorizacao && data.chaveAcesso) {
+                    const fileName = `${data.chaveAcesso}_evento_${tipoEvento}_${Date.now()}`;
+                    // Cria o path com a subpasta do tipo de evento
+                    const pathComTipoEvento = `${config.pathXMLAutorizacao}/${tipoEvento}`;
+                    this.utility.salvaXML({
+                        data: eventoXml,
+                        fileName: fileName,
+                        metodo: this.metodo,
+                        path: pathComTipoEvento,
+                    });
+                    shared.logger.info('XML do evento salvo com sucesso', {
+                        context: 'NFSeEventosService',
+                        fileName: fileName,
+                        path: pathComTipoEvento,
+                        tipoEvento: tipoEvento
+                    });
+                }
+            }
+            catch (error) {
+                shared.logger.warn('Aviso ao processar XML do evento descompactado', {
+                    context: 'NFSeEventosService',
+                    message: error.message,
+                    note: 'O evento foi registrado com sucesso, mas o XML não pôde ser salvo automaticamente'
+                });
+            }
+        }
+        return response;
+    }
+    async ConsultarEvento(data) {
+        // Salva o método original
+        const metodoOriginal = this.metodo;
+        // Muda temporariamente para consulta
+        this.metodo = 'NFSe_ConsultarEvento';
+        const response = await super.Exec(data);
+        // A consulta retorna um array de eventos com arquivoXml (Base64)
+        if (response.eventos && Array.isArray(response.eventos) && response.eventos.length > 0) {
+            const config = this.environment.getConfig();
+            // Processa cada evento retornado
+            for (const evento of response.eventos) {
+                if (evento.arquivoXml) {
+                    try {
+                        // O arquivoXml está em Base64 duplo (Base64 dentro de Base64)
+                        // Primeira decodificação: Base64 → string que contém outro Base64
+                        const primeiraDecodificacao = Buffer.from(evento.arquivoXml, 'base64').toString('utf-8');
+                        // Segunda decodificação: Base64 → buffer GZip
+                        const eventoBuffer = Buffer.from(primeiraDecodificacao, 'base64');
+                        // Descompacta o GZip para obter o XML
+                        const eventoXml = zlib.gunzipSync(eventoBuffer).toString('utf-8');
+                        // Salva o XML do evento consultado (apenas se estiver configurado)
+                        // Eventos de NFSe autorizada devem ser salvos em Autorizacao/NFSe/{tipoEvento}/
+                        shared.logger.info('Verificando configuração para salvar XML do evento consultado', {
+                            context: 'NFSeEventosService',
+                            armazenarXMLAutorizacao: config.armazenarXMLAutorizacao,
+                            pathXMLAutorizacao: config.pathXMLAutorizacao,
+                            chaveAcesso: evento.chaveAcesso,
+                            eventoXmlLength: eventoXml.length
+                        });
+                        if (config.armazenarXMLAutorizacao && config.pathXMLAutorizacao && evento.chaveAcesso) {
+                            const fileName = `${evento.chaveAcesso}_evento_${evento.tipoEvento}_${evento.numeroPedidoRegistroEvento}`;
+                            // Cria o path com a subpasta do tipo de evento em Autorizacao/NFSe
+                            const pathComTipoEvento = `${config.pathXMLAutorizacao}/${evento.tipoEvento}`;
+                            shared.logger.info('Tentando salvar XML do evento consultado', {
+                                context: 'NFSeEventosService',
+                                fileName: fileName,
+                                path: pathComTipoEvento,
+                                tipoEvento: evento.tipoEvento,
+                                metodo: this.metodo
+                            });
+                            this.utility.salvaXML({
+                                data: eventoXml,
+                                fileName: fileName,
+                                metodo: this.metodo,
+                                path: pathComTipoEvento,
+                            });
+                            shared.logger.info('XML do evento consultado salvo com sucesso', {
+                                context: 'NFSeEventosService',
+                                fileName: fileName,
+                                path: pathComTipoEvento,
+                                tipoEvento: evento.tipoEvento
+                            });
+                        }
+                        else {
+                            shared.logger.warn('XML do evento consultado não foi salvo - configuração não permite', {
+                                context: 'NFSeEventosService',
+                                armazenarXMLAutorizacao: config.armazenarXMLAutorizacao,
+                                pathXMLAutorizacao: config.pathXMLAutorizacao,
+                                chaveAcesso: evento.chaveAcesso
+                            });
+                        }
+                    }
+                    catch (error) {
+                        shared.logger.error('Erro ao processar XML do evento consultado', {
+                            context: 'NFSeEventosService',
+                            message: error.message,
+                            stack: error.stack,
+                            evento: evento
+                        });
+                    }
+                }
+            }
+        }
+        else if (response.eventoXmlGZipB64) {
+            // Fallback: se tiver eventoXmlGZipB64 (formato de registro)
+            try {
+                const eventoBuffer = Buffer.from(response.eventoXmlGZipB64, 'base64');
+                const eventoXml = zlib.gunzipSync(eventoBuffer).toString('utf-8');
+                const config = this.environment.getConfig();
+                // Eventos de NFSe autorizada devem ser salvos em Autorizacao/NFSe/{tipoEvento}/
+                if (config.armazenarXMLAutorizacao && config.pathXMLAutorizacao && data.chaveAcesso) {
+                    const fileName = `${data.chaveAcesso}_evento_${data.tipoEvento}_${data.numSeqEvento}`;
+                    // Cria o path com a subpasta do tipo de evento em Autorizacao/NFSe
+                    const pathComTipoEvento = `${config.pathXMLAutorizacao}/${data.tipoEvento}`;
+                    this.utility.salvaXML({
+                        data: eventoXml,
+                        fileName: fileName,
+                        metodo: this.metodo,
+                        path: pathComTipoEvento,
+                    });
+                    shared.logger.info('XML do evento consultado salvo com sucesso', {
+                        context: 'NFSeEventosService',
+                        fileName: fileName,
+                        path: pathComTipoEvento,
+                        tipoEvento: data.tipoEvento
+                    });
+                }
+            }
+            catch (error) {
+                shared.logger.error('Erro ao processar XML do evento consultado', {
+                    context: 'NFSeEventosService',
+                    message: error.message,
+                    stack: error.stack
+                });
+            }
+        }
+        else {
+            shared.logger.warn('Resposta da consulta não contém eventos ou eventoXmlGZipB64', {
+                context: 'NFSeEventosService',
+                response: response
+            });
+        }
+        // Restaura o método original após salvar
+        this.metodo = metodoOriginal;
+        return response;
+    }
+}
+
+/*
+ * This file is part of Treeunfe DFe.
+ *
+ * Treeunfe DFe is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Treeunfe DFe is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Treeunfe DFe. If not, see <https://www.gnu.org/licenses/>.
+ */
+class NFSeParametrosMunicipaisService extends shared.BaseNFSe {
+    constructor(environment, utility, xmlBuilder, axios, saveFiles, gerarConsulta) {
+        super(environment, utility, xmlBuilder, 'NFSe_ParametrosMunicipais', axios, saveFiles, gerarConsulta);
+    }
+    prepararDados(data) {
+        // Para GET requests, não precisa preparar dados
+        if (this.getHttpMethod() === 'GET') {
+            return null;
+        }
+        // Para POST requests (alterações), retorna o body JSON
+        if (data && 'paramXmlGZipB64' in data) {
+            return {
+                tipoAmbiente: data.tipoAmbiente,
+                paramXmlGZipB64: data.paramXmlGZipB64
+            };
+        }
+        return null;
+    }
+    getHttpMethod() {
+        // Alterações são POST, consultas são GET
+        if (this.metodo.includes('Alterar')) {
+            return 'POST';
+        }
+        return 'GET';
+    }
+    getUrlPath(data) {
+        if (!data)
+            return '';
+        // Alteração de benefício municipal: /{codigoMunicipio}/beneficiomunicipal/{idManut}
+        if (this.metodo.includes('AlterarBeneficio')) {
+            return `/${data.codigoMunicipio}/beneficiomunicipal/${data.idManut}`;
+        }
+        // Alteração de retenções: /{codigoMunicipio}/retencoes/{idManut}
+        if (this.metodo.includes('AlterarRetencoes')) {
+            return `/${data.codigoMunicipio}/retencoes/${data.idManut}`;
+        }
+        // Consulta de alíquota: /{codigoMunicipio}/{codigoServico}/{competencia}/aliquota
+        if (this.metodo.includes('ConsultarAliquota') && 'codigoServico' in data && 'competencia' in data) {
+            const competencia = encodeURIComponent(data.competencia);
+            return `/${data.codigoMunicipio}/${data.codigoServico}/${competencia}/aliquota`;
+        }
+        // Consulta de histórico de alíquotas: /{codigoMunicipio}/{codigoServico}/historicoaliquotas
+        if (this.metodo.includes('ConsultarHistoricoAliquotas')) {
+            return `/${data.codigoMunicipio}/${data.codigoServico}/historicoaliquotas`;
+        }
+        // Consulta de benefício: /{codigoMunicipio}/{numeroBeneficio}/{competencia}/beneficio
+        if (this.metodo.includes('ConsultarBeneficio')) {
+            const competencia = encodeURIComponent(data.competencia);
+            return `/${data.codigoMunicipio}/${data.numeroBeneficio}/${competencia}/beneficio`;
+        }
+        // Consulta de convênio: /{codigoMunicipio}/convenio
+        if (this.metodo.includes('ConsultarConvenio')) {
+            return `/${data.codigoMunicipio}/convenio`;
+        }
+        // Consulta de regimes especiais: /{codigoMunicipio}/{codigoServico}/{competencia}/regimes_especiais
+        if (this.metodo.includes('ConsultarRegimesEspeciais')) {
+            const competencia = encodeURIComponent(data.competencia);
+            return `/${data.codigoMunicipio}/${data.codigoServico}/${competencia}/regimes_especiais`;
+        }
+        return '';
+    }
+    getWebServiceUrl() {
+        return this.utility.getWebServiceUrlNFSe('NFSe_ParametrosMunicipais');
+    }
+    async ConsultarAliquota(data) {
+        this.metodo = 'NFSe_ConsultarAliquota';
+        return await super.Exec(data);
+    }
+    async ConsultarHistoricoAliquotas(data) {
+        this.metodo = 'NFSe_ConsultarHistoricoAliquotas';
+        return await super.Exec(data);
+    }
+    async ConsultarBeneficio(data) {
+        this.metodo = 'NFSe_ConsultarBeneficio';
+        return await super.Exec(data);
+    }
+    async ConsultarConvenio(data) {
+        this.metodo = 'NFSe_ConsultarConvenio';
+        return await super.Exec(data);
+    }
+    async ConsultarRegimesEspeciais(data) {
+        this.metodo = 'NFSe_ConsultarRegimesEspeciais';
+        return await super.Exec(data);
+    }
+    async AlterarBeneficioMunicipal(data) {
+        this.metodo = 'NFSe_AlterarBeneficioMunicipal';
+        const response = await super.Exec(data);
+        return {
+            sucesso: true,
+            mensagem: response.mensagem
+        };
+    }
+    async AlterarRetencoes(data) {
+        this.metodo = 'NFSe_AlterarRetencoes';
+        const response = await super.Exec(data);
+        return {
+            sucesso: true,
+            mensagem: response.mensagem
+        };
+    }
+}
+
+/*
+ * This file is part of Treeunfe DFe.
+ *
+ * Treeunfe DFe is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Treeunfe DFe is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Treeunfe DFe. If not, see <https://www.gnu.org/licenses/>.
+ */
+class NFSeDanfeService extends shared.BaseNFSe {
+    constructor(environment, utility, xmlBuilder, axios, saveFiles, gerarConsulta) {
+        super(environment, utility, xmlBuilder, 'NFSe_DANFSe', axios, saveFiles, gerarConsulta);
+    }
+    prepararDados(_data) {
+        return null; // GET request não precisa de body
+    }
+    getHttpMethod() {
+        return 'GET';
+    }
+    getUrlPath(data) {
+        if (data && 'chaveAcesso' in data) {
+            return `/${data.chaveAcesso}`;
+        }
+        return '';
+    }
+    getWebServiceUrl() {
+        return this.utility.getWebServiceUrlNFSe('NFSe_DANFSe');
+    }
+    async GerarDanfe(data) {
+        try {
+            const baseUrl = this.getWebServiceUrl();
+            const pathUrl = this.getUrlPath(data);
+            const webServiceUrl = baseUrl + pathUrl;
+            shared.logger.http('Iniciando geração de DANFSe', {
+                context: 'NFSeDanfeService',
+                method: this.metodo,
+                url: webServiceUrl,
+                chaveAcesso: data.chaveAcesso,
+            });
+            // Obtém o agent HTTPS do environment para garantir autenticação mútua TLS
+            const agent = this.environment.getHttpAgent();
+            const requestConfig = {
+                headers: {
+                    'Accept': 'application/pdf',
+                },
+                responseType: 'arraybuffer',
+                httpsAgent: agent
+            };
+            const response = await this.axios.get(webServiceUrl, requestConfig);
+            // Garante que o diretório existe
+            const outputDir = path.dirname(data.outputPath);
+            if (!fs.existsSync(outputDir)) {
+                fs.mkdirSync(outputDir, { recursive: true });
+            }
+            // Salva o PDF
+            fs.writeFileSync(data.outputPath, response.data);
+            shared.logger.http('DANFSe gerada com sucesso', {
+                context: 'NFSeDanfeService',
+                outputPath: data.outputPath,
+            });
+            return {
+                success: true,
+                message: `DANFSe gerada em '${data.outputPath}'`,
+            };
+        }
+        catch (error) {
+            shared.logger.error('Erro ao gerar DANFSe', error, {
+                context: 'NFSeDanfeService',
+            });
+            throw new Error(`Erro ao gerar DANFSe: ${error.message}`);
+        }
+    }
+}
+
+/*
+ * This file is part of Treeunfe DFe.
+ *
+ * Treeunfe DFe is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Treeunfe DFe is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Treeunfe DFe. If not, see <https://www.gnu.org/licenses/>.
+ */
+class NFSe {
+    constructor(config) {
+        // Valida se a configuração obrigatória foi fornecida
+        if (!config.ambiente) {
+            throw new Error('Configuração NFSe incompleta. Por favor, forneça "ambiente".');
+        }
+        // Cria o environment próprio - passa a config diretamente
+        const environment = new shared.Environment(config);
+        this.environment = environment;
+        // Carrega o environment automaticamente
+        this.loadEnvironmentPromise = (async () => {
+            try {
+                const { axios: axiosInstance } = await environment.loadEnvironment();
+                this.axios = axiosInstance;
+                this.utility = new shared.Utility(environment);
+                this.saveFiles = new shared.SaveFiles(environment, this.utility);
+                this.xmlBuilder = new shared.XmlBuilder(environment);
+                this.gerarConsulta = new shared.GerarConsulta(environment, this.utility, this.xmlBuilder);
+            }
+            catch (error) {
+                shared.logger.error(``, error, { context: 'NFSE_LoadEnvironment' });
+                throw new Error(`Erro ao inicializar a lib NFSe: ${error}`);
+            }
+        })();
+    }
+    /**
+     * Autorização de NFSe
+     */
+    async Autorizacao(data) {
+        await this.loadEnvironmentPromise;
+        try {
+            const service = new NFSeAutorizacaoService(this.environment, this.utility, this.xmlBuilder, this.axios, this.saveFiles, this.gerarConsulta);
+            const operation = new NFSeAutorizacao(service);
+            const response = await operation.Exec(data);
+            console.log('Retorno NFSE_Autorizacao');
+            console.log(`   Chave de Acesso: ${response.response.chaveAcesso || 'N/A'}`);
+            console.log('===================================');
+            return response;
+        }
+        catch (error) {
+            shared.logger.error(``, error, { context: 'NFSE_Autorizacao' });
+            throw new Error(`NFSE_Autorizacao: ${error.message}`);
+        }
+    }
+    /**
+     * Consulta NFSe por chave de acesso
+     */
+    async Consulta(data) {
+        await this.loadEnvironmentPromise;
+        try {
+            const service = new NFSeConsultaService(this.environment, this.utility, this.xmlBuilder, this.axios, this.saveFiles, this.gerarConsulta);
+            const operation = new NFSeConsulta(service);
+            const response = await operation.Exec(data);
+            console.log('Retorno NFSE_Consulta');
+            console.log(`   Chave de Acesso: ${response.chaveAcesso || 'N/A'}`);
+            console.log('===================================');
+            return response;
+        }
+        catch (error) {
+            shared.logger.error(``, error, { context: 'NFSE_Consulta' });
+            throw new Error(`NFSE_Consulta: ${error.message}`);
+        }
+    }
+    /**
+     * Consulta DPS por ID
+     */
+    async ConsultaDPS(data) {
+        await this.loadEnvironmentPromise;
+        try {
+            const service = new NFSeConsultaService(this.environment, this.utility, this.xmlBuilder, this.axios, this.saveFiles, this.gerarConsulta);
+            const operation = new NFSeConsulta(service);
+            const response = await operation.ConsultaDPS(data);
+            console.log('Retorno NFSE_ConsultaDPS');
+            console.log(`   Chave de Acesso: ${response.chaveAcesso || 'N/A'}`);
+            console.log('===================================');
+            return response;
+        }
+        catch (error) {
+            shared.logger.error(``, error, { context: 'NFSE_ConsultaDPS' });
+            throw new Error(`NFSE_ConsultaDPS: ${error.message}`);
+        }
+    }
+    /**
+     * Registro de Eventos
+     */
+    async RegistrarEvento(data) {
+        await this.loadEnvironmentPromise;
+        try {
+            const service = new NFSeEventosService(this.environment, this.utility, this.xmlBuilder, this.axios, this.saveFiles, this.gerarConsulta);
+            const operation = new NFSeEventos(service);
+            const response = await operation.RegistrarEvento(data);
+            console.log('Retorno NFSE_RegistrarEvento');
+            console.log(`   Processado com sucesso`);
+            console.log('===================================');
+            return response;
+        }
+        catch (error) {
+            shared.logger.error(``, error, { context: 'NFSE_RegistrarEvento' });
+            throw new Error(`NFSE_RegistrarEvento: ${error.message}`);
+        }
+    }
+    /**
+     * Consulta de Eventos
+     */
+    async ConsultarEvento(data) {
+        await this.loadEnvironmentPromise;
+        try {
+            const service = new NFSeEventosService(this.environment, this.utility, this.xmlBuilder, this.axios, this.saveFiles, this.gerarConsulta);
+            const operation = new NFSeEventos(service);
+            const response = await operation.ConsultarEvento(data);
+            console.log('Retorno NFSE_ConsultarEvento');
+            console.log(`   Processado com sucesso`);
+            console.log('===================================');
+            return response;
+        }
+        catch (error) {
+            shared.logger.error(``, error, { context: 'NFSE_ConsultarEvento' });
+            throw new Error(`NFSE_ConsultarEvento: ${error.message}`);
+        }
+    }
+    /**
+     * Distribuição por NSU
+     */
+    async DistribuicaoPorNSU(data) {
+        await this.loadEnvironmentPromise;
+        try {
+            const service = new NFSeDistribuicaoService(this.environment, this.utility, this.xmlBuilder, this.axios, this.saveFiles, this.gerarConsulta);
+            const operation = new NFSeDistribuicao(service);
+            const response = await operation.DistribuicaoPorNSU(data);
+            console.log('Retorno NFSE_DistribuicaoPorNSU');
+            console.log(`   Status: ${response.StatusProcessamento || 'N/A'}`);
+            console.log('===================================');
+            return response;
+        }
+        catch (error) {
+            shared.logger.error(``, error, { context: 'NFSE_DistribuicaoPorNSU' });
+            throw new Error(`NFSE_DistribuicaoPorNSU: ${error.message}`);
+        }
+    }
+    /**
+     * Eventos por chave de acesso
+     */
+    async EventosPorChave(data) {
+        await this.loadEnvironmentPromise;
+        try {
+            const service = new NFSeDistribuicaoService(this.environment, this.utility, this.xmlBuilder, this.axios, this.saveFiles, this.gerarConsulta);
+            const operation = new NFSeDistribuicao(service);
+            const response = await operation.EventosPorChave(data);
+            console.log('Retorno NFSE_EventosPorChave');
+            console.log(`   Status: ${response.StatusProcessamento || 'N/A'}`);
+            console.log('===================================');
+            return response;
+        }
+        catch (error) {
+            shared.logger.error(``, error, { context: 'NFSE_EventosPorChave' });
+            throw new Error(`NFSE_EventosPorChave: ${error.message}`);
+        }
+    }
+    /**
+     * Consulta Alíquota
+     */
+    async ConsultarAliquota(data) {
+        await this.loadEnvironmentPromise;
+        try {
+            const service = new NFSeParametrosMunicipaisService(this.environment, this.utility, this.xmlBuilder, this.axios, this.saveFiles, this.gerarConsulta);
+            const operation = new NFSeParametrosMunicipais(service);
+            const response = await operation.ConsultarAliquota(data);
+            console.log('Retorno NFSE_ConsultarAliquota');
+            console.log(`   Mensagem: ${response.mensagem || 'N/A'}`);
+            console.log('===================================');
+            return response;
+        }
+        catch (error) {
+            shared.logger.error(``, error, { context: 'NFSE_ConsultarAliquota' });
+            throw new Error(`NFSE_ConsultarAliquota: ${error.message}`);
+        }
+    }
+    /**
+     * Consulta Histórico de Alíquotas
+     */
+    async ConsultarHistoricoAliquotas(data) {
+        await this.loadEnvironmentPromise;
+        try {
+            const service = new NFSeParametrosMunicipaisService(this.environment, this.utility, this.xmlBuilder, this.axios, this.saveFiles, this.gerarConsulta);
+            const operation = new NFSeParametrosMunicipais(service);
+            const response = await operation.ConsultarHistoricoAliquotas(data);
+            console.log('Retorno NFSE_ConsultarHistoricoAliquotas');
+            console.log(`   Mensagem: ${response.mensagem || 'N/A'}`);
+            console.log('===================================');
+            return response;
+        }
+        catch (error) {
+            shared.logger.error(``, error, { context: 'NFSE_ConsultarHistoricoAliquotas' });
+            throw new Error(`NFSE_ConsultarHistoricoAliquotas: ${error.message}`);
+        }
+    }
+    /**
+     * Consulta Benefício Municipal
+     */
+    async ConsultarBeneficio(data) {
+        await this.loadEnvironmentPromise;
+        try {
+            const service = new NFSeParametrosMunicipaisService(this.environment, this.utility, this.xmlBuilder, this.axios, this.saveFiles, this.gerarConsulta);
+            const operation = new NFSeParametrosMunicipais(service);
+            const response = await operation.ConsultarBeneficio(data);
+            console.log('Retorno NFSE_ConsultarBeneficio');
+            console.log(`   Mensagem: ${response.mensagem || 'N/A'}`);
+            console.log('===================================');
+            return response;
+        }
+        catch (error) {
+            shared.logger.error(``, error, { context: 'NFSE_ConsultarBeneficio' });
+            throw new Error(`NFSE_ConsultarBeneficio: ${error.message}`);
+        }
+    }
+    /**
+     * Consulta Convênio Municipal
+     */
+    async ConsultarConvenio(data) {
+        await this.loadEnvironmentPromise;
+        try {
+            const service = new NFSeParametrosMunicipaisService(this.environment, this.utility, this.xmlBuilder, this.axios, this.saveFiles, this.gerarConsulta);
+            const operation = new NFSeParametrosMunicipais(service);
+            const response = await operation.ConsultarConvenio(data);
+            console.log('Retorno NFSE_ConsultarConvenio');
+            console.log(`   Mensagem: ${response.mensagem || 'N/A'}`);
+            console.log('===================================');
+            return response;
+        }
+        catch (error) {
+            shared.logger.error(``, error, { context: 'NFSE_ConsultarConvenio' });
+            throw new Error(`NFSE_ConsultarConvenio: ${error.message}`);
+        }
+    }
+    /**
+     * Consulta Regimes Especiais
+     */
+    async ConsultarRegimesEspeciais(data) {
+        await this.loadEnvironmentPromise;
+        try {
+            const service = new NFSeParametrosMunicipaisService(this.environment, this.utility, this.xmlBuilder, this.axios, this.saveFiles, this.gerarConsulta);
+            const operation = new NFSeParametrosMunicipais(service);
+            const response = await operation.ConsultarRegimesEspeciais(data);
+            console.log('Retorno NFSE_ConsultarRegimesEspeciais');
+            console.log(`   Mensagem: ${response.mensagem || 'N/A'}`);
+            console.log('===================================');
+            return response;
+        }
+        catch (error) {
+            shared.logger.error(``, error, { context: 'NFSE_ConsultarRegimesEspeciais' });
+            throw new Error(`NFSE_ConsultarRegimesEspeciais: ${error.message}`);
+        }
+    }
+    /**
+     * Alterar Benefício Municipal
+     */
+    async AlterarBeneficioMunicipal(data) {
+        await this.loadEnvironmentPromise;
+        try {
+            const service = new NFSeParametrosMunicipaisService(this.environment, this.utility, this.xmlBuilder, this.axios, this.saveFiles, this.gerarConsulta);
+            const operation = new NFSeParametrosMunicipais(service);
+            const response = await operation.AlterarBeneficioMunicipal(data);
+            console.log('Retorno NFSE_AlterarBeneficioMunicipal');
+            console.log(`   Sucesso: ${response.sucesso}`);
+            console.log(`   Mensagem: ${response.mensagem || 'N/A'}`);
+            console.log('===================================');
+            return response;
+        }
+        catch (error) {
+            shared.logger.error(``, error, { context: 'NFSE_AlterarBeneficioMunicipal' });
+            throw new Error(`NFSE_AlterarBeneficioMunicipal: ${error.message}`);
+        }
+    }
+    /**
+     * Alterar Retenções
+     */
+    async AlterarRetencoes(data) {
+        await this.loadEnvironmentPromise;
+        try {
+            const service = new NFSeParametrosMunicipaisService(this.environment, this.utility, this.xmlBuilder, this.axios, this.saveFiles, this.gerarConsulta);
+            const operation = new NFSeParametrosMunicipais(service);
+            const response = await operation.AlterarRetencoes(data);
+            console.log('Retorno NFSE_AlterarRetencoes');
+            console.log(`   Sucesso: ${response.sucesso}`);
+            console.log(`   Mensagem: ${response.mensagem || 'N/A'}`);
+            console.log('===================================');
+            return response;
+        }
+        catch (error) {
+            shared.logger.error(``, error, { context: 'NFSE_AlterarRetencoes' });
+            throw new Error(`NFSE_AlterarRetencoes: ${error.message}`);
+        }
+    }
+    /**
+     * Gerar DANFSe
+     */
+    async GerarDanfe(data) {
+        await this.loadEnvironmentPromise;
+        try {
+            const service = new NFSeDanfeService(this.environment, this.utility, this.xmlBuilder, this.axios, this.saveFiles, this.gerarConsulta);
+            const operation = new NFSeDanfe(service);
+            const response = await operation.GerarDanfe(data);
+            console.log('Retorno NFSE_GerarDanfe');
+            console.log(response.message);
+            console.log('===================================');
+            return response;
+        }
+        catch (error) {
+            shared.logger.error(``, error, { context: 'NFSE_GerarDanfe' });
+            throw new Error(`NFSE_GerarDanfe: ${error.message}`);
+        }
+    }
+}
+
+exports.NFSe = NFSe;
+exports.NFSeAutorizacao = NFSeAutorizacao;
+exports.NFSeAutorizacaoService = NFSeAutorizacaoService;
+exports.NFSeConsulta = NFSeConsulta;
+exports.NFSeConsultaService = NFSeConsultaService;
+exports.NFSeDanfe = NFSeDanfe;
+exports.NFSeDanfeService = NFSeDanfeService;
+exports.NFSeDistribuicao = NFSeDistribuicao;
+exports.NFSeDistribuicaoService = NFSeDistribuicaoService;
+exports.NFSeEventos = NFSeEventos;
+exports.NFSeEventosService = NFSeEventosService;
+exports.NFSeParametrosMunicipais = NFSeParametrosMunicipais;
+exports.NFSeParametrosMunicipaisService = NFSeParametrosMunicipaisService;
+Object.keys(types).forEach(function (k) {
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function () { return types[k]; }
+    });
+});
+//# sourceMappingURL=index.cjs.map