@nfewizard/shared 1.0.0 → 1.0.1

package/dist/index.mjs

@@ -7,6 +7,7 @@ import { format } from 'date-fns';
 import xml2js from 'xml2js';
 import { SignedXml } from 'xml-crypto';
 import { fileURLToPath } from 'url';
+import crypto from 'crypto';
 import xsdValidator from 'xsd-schema-validator';
 import libxmljs from 'libxmljs2';
 import xsdAssembler from 'xsd-assembler';
@@ -15,6 +16,22 @@ import pem from 'pem';
 import https from 'https';
 import forge from 'node-forge';
 
+/*
+ * This file is part of NFeWizard-io.
+ *
+ * NFeWizard-io 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.
+ *
+ * NFeWizard-io 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 NFeWizard-io. If not, see <https://www.gnu.org/licenses/>.
+ */
 class JsonArrayTransport extends Transport {
     constructor(options) {
         super(options);
@@ -95,6 +112,22 @@ class JsonArrayTransport extends Transport {
     }
 }
 
+/*
+ * This file is part of NFeWizard-io.
+ *
+ * NFeWizard-io 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.
+ *
+ * NFeWizard-io 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 NFeWizard-io. If not, see <https://www.gnu.org/licenses/>.
+ */
 class AppLogger {
     constructor() {
         this.isInitialized = false;
@@ -495,6 +528,196 @@ class BaseNFE {
     }
 }
 
+class BaseNFSe {
+    constructor(environment, utility, xmlBuilder, metodo, axios, saveFiles, gerarConsulta) {
+        this.environment = environment;
+        this.utility = utility;
+        this.xmlBuilder = xmlBuilder;
+        this.metodo = metodo;
+        this.axios = axios;
+        this.saveFiles = saveFiles;
+        this.gerarConsulta = gerarConsulta;
+    }
+    /**
+     * Método de preparação dos dados - Deve ser implementado pelas subclasses
+     */
+    prepararDados(_data) {
+        throw new Error("O método 'prepararDados' não foi implementado na subclasse.");
+    }
+    /**
+     * Método para obter a URL base do webservice
+     */
+    getWebServiceUrl() {
+        return this.utility.getWebServiceUrlNFSe(this.metodo);
+    }
+    /**
+     * Método para obter o método HTTP (GET, POST, etc)
+     */
+    getHttpMethod() {
+        return 'POST'; // Padrão para NFSe
+    }
+    /**
+     * Método para obter o path adicional da URL (ex: /nfse/{chaveAcesso})
+     */
+    getUrlPath(_data) {
+        return '';
+    }
+    /**
+     * Método para obter query parameters
+     */
+    getQueryParams(_data) {
+        return {};
+    }
+    /**
+     * Executa a requisição ao webservice NFSe (REST API)
+     * @param {any} [data] - Dados opcionais usados para preparar a requisição.
+     * @returns {Promise<any>} A resposta do webservice em JSON.
+     */
+    async Exec(data) {
+        let requestData = null;
+        let webServiceUrl = '';
+        let responseInJson = undefined;
+        let response = {};
+        let errorResponse = null;
+        try {
+            // Prepara dados específicos
+            requestData = this.prepararDados(data);
+            // Obtém URL base
+            const baseUrl = this.getWebServiceUrl();
+            const path = this.getUrlPath(data);
+            const queryParams = this.getQueryParams(data);
+            // Monta URL completa
+            webServiceUrl = baseUrl + path;
+            if (Object.keys(queryParams).length > 0) {
+                const queryString = new URLSearchParams(queryParams).toString();
+                webServiceUrl += `?${queryString}`;
+            }
+            const httpMethod = this.getHttpMethod();
+            logger.http('Iniciando comunicação com o webservice NFSe', {
+                context: `BaseNFSe`,
+                method: this.metodo,
+                httpMethod,
+                url: webServiceUrl,
+            });
+            // Executa requisição REST
+            // Obtém o agent HTTPS do environment para garantir autenticação mútua TLS
+            const agent = this.environment.getHttpAgent();
+            const requestConfig = {
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Accept': 'application/json',
+                },
+                // Garante que o httpsAgent seja usado explicitamente para autenticação mútua TLS
+                httpsAgent: agent
+            };
+            if (httpMethod === 'GET') {
+                response = await this.axios.get(webServiceUrl, requestConfig);
+            }
+            else if (httpMethod === 'POST') {
+                response = await this.axios.post(webServiceUrl, requestData, requestConfig);
+            }
+            else if (httpMethod === 'PUT') {
+                response = await this.axios.put(webServiceUrl, requestData, requestConfig);
+            }
+            else if (httpMethod === 'DELETE') {
+                response = await this.axios.delete(webServiceUrl, requestConfig);
+            }
+            logger.http('Comunicação concluída com sucesso', {
+                context: `BaseNFSe`,
+                method: this.metodo,
+                responseSize: response.data ? JSON.stringify(response.data).length : 0
+            });
+            // NFSe retorna JSON diretamente
+            responseInJson = response.data;
+            // Verifica se há erros na resposta
+            if (responseInJson) {
+                if (responseInJson.erros && Array.isArray(responseInJson.erros) && responseInJson.erros.length > 0) {
+                    const primeiroErro = responseInJson.erros[0];
+                    const mensagemErro = primeiroErro.descricao || primeiroErro.Descricao || 'Erro desconhecido';
+                    throw new Error(mensagemErro);
+                }
+                if (responseInJson.Erros && Array.isArray(responseInJson.Erros) && responseInJson.Erros.length > 0) {
+                    const primeiroErro = responseInJson.Erros[0];
+                    const mensagemErro = primeiroErro.Descricao || primeiroErro.descricao || 'Erro desconhecido';
+                    throw new Error(mensagemErro);
+                }
+            }
+            return responseInJson || {};
+        }
+        catch (error) {
+            // Armazena a resposta de erro para uso no finally
+            errorResponse = error.response;
+            // Tenta extrair mais informações do erro
+            let errorMessage = error.message || 'Erro desconhecido';
+            if (error.response) {
+                // Erro de resposta HTTP
+                // Tenta extrair mensagem do body da resposta
+                if (error.response.data) {
+                    if (typeof error.response.data === 'string') {
+                        errorMessage = `HTTP ${error.response.status}: ${error.response.data}`;
+                    }
+                    else if (error.response.data.erros && Array.isArray(error.response.data.erros) && error.response.data.erros.length > 0) {
+                        // NFSe retorna erros em um array
+                        const primeiroErro = error.response.data.erros[0];
+                        const codigo = primeiroErro.codigo || primeiroErro.Codigo || '';
+                        const descricao = primeiroErro.descricao || primeiroErro.Descricao || 'Erro desconhecido';
+                        errorMessage = codigo ? `${codigo}: ${descricao}` : descricao;
+                    }
+                    else if (error.response.data.Erros && Array.isArray(error.response.data.Erros) && error.response.data.Erros.length > 0) {
+                        // Variação com E maiúsculo
+                        const primeiroErro = error.response.data.Erros[0];
+                        const codigo = primeiroErro.Codigo || primeiroErro.codigo || '';
+                        const descricao = primeiroErro.Descricao || primeiroErro.descricao || 'Erro desconhecido';
+                        errorMessage = codigo ? `${codigo}: ${descricao}` : descricao;
+                    }
+                    else if (error.response.data.message) {
+                        errorMessage = error.response.data.message;
+                    }
+                    else if (error.response.data.descricao) {
+                        errorMessage = error.response.data.descricao;
+                    }
+                    else if (error.response.data.Descricao) {
+                        errorMessage = error.response.data.Descricao;
+                    }
+                    else {
+                        errorMessage = `HTTP ${error.response.status}: ${JSON.stringify(error.response.data)}`;
+                    }
+                }
+                else {
+                    errorMessage = `HTTP ${error.response.status}: ${error.response.statusText}`;
+                }
+            }
+            logger.error(``, error, {
+                context: `BaseNFSe][${this.metodo}`
+            });
+            throw new Error(errorMessage);
+        }
+        finally {
+            // Salva arquivos (se configurado)
+            // Para REST, salva o JSON da requisição
+            const xmlConsulta = requestData ? JSON.stringify(requestData, null, 2) : '';
+            this.saveFiles.salvaArquivos(xmlConsulta, responseInJson, errorResponse || response, this.metodo, '' // xmlConsultaSoap vazio para REST
+            );
+        }
+    }
+}
+
+/*
+ * This file is part of NFeWizard-io.
+ *
+ * NFeWizard-io 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.
+ *
+ * NFeWizard-io 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 NFeWizard-io. If not, see <https://www.gnu.org/licenses/>.
+ */
 class GerarConsulta {
     constructor(environment, utility, xmlBuilder) {
         this.environment = environment;
@@ -518,20 +741,31 @@ class GerarConsulta {
     async gerarConsulta(xmlConsulta, metodo, ambienteNacional = false, versao = "", mod = "NFe", rootTag = false, tag = "", dadosMsgTag = "nfeDadosMsg") {
         try {
             const config = this.environment.getConfig();
-            // Valida Schema
-            if (config.lib?.useForSchemaValidation !== 'validateSchemaJsBased') {
-                logger.info(`Validando XML com xsd-schema-validator`, {
-                    context: 'GerarConsulta',
-                    obs: 'Validação necessita do JAVA instaldo no ambiente',
-                });
-                await this.utility.validateSchemaJavaBased(xmlConsulta, metodo);
+            // Capturando o schema path
+            const { schemaPath } = this.utility.getSchema(metodo);
+            // Valida Schema apenas se o schema path estiver definido
+            if (schemaPath) {
+                if (config.lib?.useForSchemaValidation !== 'validateSchemaJsBased') {
+                    logger.info(`Validando XML com xsd-schema-validator`, {
+                        context: 'GerarConsulta',
+                        obs: 'Validação necessita do JAVA instaldo no ambiente',
+                    });
+                    await this.utility.validateSchemaJavaBased(xmlConsulta, metodo);
+                }
+                else {
+                    logger.info(`Validando XML com xsd-assembler`, {
+                        context: 'GerarConsulta',
+                        obs: 'Validação com nodejs',
+                    });
+                    await this.utility.validateSchemaJsBased(xmlConsulta, metodo);
+                }
             }
             else {
-                logger.info(`Validando XML com xsd-assembler`, {
+                logger.info(`Pulando validação de schema`, {
                     context: 'GerarConsulta',
-                    obs: 'Validação com nodejs',
+                    metodo,
+                    obs: 'Schema XSD não disponível para este método',
                 });
-                await this.utility.validateSchemaJsBased(xmlConsulta, metodo);
             }
             // Capturando a url do método para o namespace xmlns
             const { method, action } = this.utility.getSoapInfo(config.dfe.UF, metodo);
@@ -592,8 +826,14 @@ class SaveFiles {
         const salvarArquivo = (data, prefix, path, fileType) => {
             const fileName = createFileName(prefix);
             const method = fileType === 'xml' ? 'salvaXML' : 'salvaJSON';
+            // Para REST API (NFSe), o data pode ser um objeto JSON mesmo quando fileType é 'xml'
+            // Neste caso, converte para string JSON
+            let dataToSave = data || '';
+            if (fileType === 'xml' && typeof data === 'object' && data !== null) {
+                dataToSave = JSON.stringify(data, null, 2);
+            }
             this.utility[method]({
-                data: data || '',
+                data: dataToSave,
                 fileName,
                 metodo: metodo,
                 path,
@@ -756,6 +996,12 @@ const getSchema = (metodo) => {
         NFEInutilizacao: `${pathSchemas}/inutNFe_v4.00.xsd`,
         NFERetAutorizacao: `${pathSchemas}/consReciNFe_v4.00.xsd`,
         CTeDistribuicaoDFe: `${pathSchemas}/cte/distDFeInt_v1.00.xsd`,
+        // NFSe - Schemas da Nota Fiscal de Serviços Eletrônica
+        NFSe_Autorizacao: `${pathSchemas}/nfse/DPS_v1.01.xsd`,
+        NFSe_Consulta: `${pathSchemas}/nfse/NFSe_v1.01.xsd`,
+        NFSe_Distribuicao: `${pathSchemas}/nfse/NFSe_v1.01.xsd`,
+        NFSe_Eventos: `${pathSchemas}/nfse/pedRegEvento_v1.01.xsd`,
+        NFSe_ParametrosMunicipais: undefined, // API REST - não usa XML schema
     };
     try {
         return {
@@ -2288,6 +2534,31 @@ var CTeServicosUrl = {
 	CTe_AN_H: CTe_AN_H
 };
 
+var NFSe_AN_P = {
+	NFSe_Autorizacao: "https://sefin.nfse.gov.br/SefinNacional/nfse",
+	NFSe_Consulta: "https://sefin.nfse.gov.br/SefinNacional/nfse",
+	NFSe_ConsultaDPS: "https://sefin.nfse.gov.br/SefinNacional/dps",
+	NFSe_Eventos: "https://sefin.nfse.gov.br/SefinNacional/nfse",
+	NFSe_Distribuicao: "https://adn.nfse.gov.br/contribuintes/DFe",
+	NFSe_EventosPorChave: "https://adn.nfse.gov.br/contribuintes/NFSe",
+	NFSe_DANFSe: "https://adn.nfse.gov.br/danfse",
+	NFSe_ParametrosMunicipais: "https://adn.nfse.gov.br/parametrizacao"
+};
+var NFSe_AN_H = {
+	NFSe_Autorizacao: "https://sefin.producaorestrita.nfse.gov.br/SefinNacional/nfse",
+	NFSe_Consulta: "https://sefin.producaorestrita.nfse.gov.br/SefinNacional/nfse",
+	NFSe_ConsultaDPS: "https://sefin.producaorestrita.nfse.gov.br/SefinNacional/dps",
+	NFSe_Eventos: "https://sefin.producaorestrita.nfse.gov.br/SefinNacional/nfse",
+	NFSe_Distribuicao: "https://adn.producaorestrita.nfse.gov.br/contribuintes/DFe",
+	NFSe_EventosPorChave: "https://adn.producaorestrita.nfse.gov.br/contribuintes/NFSe",
+	NFSe_DANFSe: "https://adn.producaorestrita.nfse.gov.br/danfse",
+	NFSe_ParametrosMunicipais: "https://adn.producaorestrita.nfse.gov.br/parametrizacao"
+};
+var NFSeServicosUrl = {
+	NFSe_AN_P: NFSe_AN_P,
+	NFSe_AN_H: NFSe_AN_H
+};
+
 var NFEStatusServico = {
 	method: "http://www.portalfiscal.inf.br/nfe/wsdl/NFeStatusServico4",
 	action: ""
@@ -2332,6 +2603,26 @@ var CTeDistribuicaoDFe = {
 	method: "http://www.portalfiscal.inf.br/cte/wsdl/CTeDistribuicaoDFe",
 	action: "http://www.portalfiscal.inf.br/cte/wsdl/CTeDistribuicaoDFe/cteDistDFeInteresse"
 };
+var NFSe_Autorizacao = {
+	method: "http://www.sped.fazenda.gov.br/nfse/wsdl/NFSeRecepcao",
+	action: "http://www.sped.fazenda.gov.br/nfse/wsdl/NFSeRecepcao/recepcionar"
+};
+var NFSe_Consulta = {
+	method: "http://www.sped.fazenda.gov.br/nfse/wsdl/NFSeConsulta",
+	action: "http://www.sped.fazenda.gov.br/nfse/wsdl/NFSeConsulta/consultar"
+};
+var NFSe_Distribuicao = {
+	method: "http://www.sped.fazenda.gov.br/nfse/wsdl/NFSeDistribuicao",
+	action: "http://www.sped.fazenda.gov.br/nfse/wsdl/NFSeDistribuicao/distribuir"
+};
+var NFSe_Eventos = {
+	method: "http://www.sped.fazenda.gov.br/nfse/wsdl/NFSeRecepcaoEvento",
+	action: "http://www.sped.fazenda.gov.br/nfse/wsdl/NFSeRecepcaoEvento/recepcionar"
+};
+var NFSe_ParametrosMunicipais = {
+	method: "http://www.sped.fazenda.gov.br/nfse/wsdl/NFSeParametros",
+	action: "http://www.sped.fazenda.gov.br/nfse/wsdl/NFSeParametros/consultar"
+};
 var soapMethod = {
 	NFEStatusServico: NFEStatusServico,
 	NFeDistribuicaoDFe: NFeDistribuicaoDFe,
@@ -2343,7 +2634,12 @@ var soapMethod = {
 	NFEConsultaProtocolo: NFEConsultaProtocolo,
 	consultarCadastro: consultarCadastro,
 	RecepcaoEvento: RecepcaoEvento,
-	CTeDistribuicaoDFe: CTeDistribuicaoDFe
+	CTeDistribuicaoDFe: CTeDistribuicaoDFe,
+	NFSe_Autorizacao: NFSe_Autorizacao,
+	NFSe_Consulta: NFSe_Consulta,
+	NFSe_Distribuicao: NFSe_Distribuicao,
+	NFSe_Eventos: NFSe_Eventos,
+	NFSe_ParametrosMunicipais: NFSe_ParametrosMunicipais
 };
 
 /**
@@ -2412,6 +2708,12 @@ class Utility {
         this.environment = environment;
         this.xmlParser = new XmlParser();
     }
+    /**
+     * Retorna schema XSD para validação do XML
+     */
+    getSchema(metodo) {
+        return getSchema(metodo);
+    }
     /**
      * Método utilitário para criar diretórios
      */
@@ -2623,10 +2925,39 @@ class Utility {
         const chaveFilha = `${metodo}_${versaoDF}`;
         return { chaveMae, chaveFilha };
     }
+    /**
+     * Retorna a url correta do webservice NFSe (REST API)
+     */
+    getWebServiceUrlNFSe(metodo) {
+        const nfseUrls = NFSeServicosUrl;
+        const config = this.environment.config;
+        if (!config.nfe.ambiente) {
+            throw new Error('Configuração de ambiente não encontrada. É necessária para operações de NFSe.');
+        }
+        const ambiente = config.nfe.ambiente === 1 ? 'P' : 'H';
+        const chave = `NFSe_AN_${ambiente}`; // AN = Ambiente Nacional
+        const url = nfseUrls[chave] && nfseUrls[chave][metodo];
+        if (!url) {
+            throw new Error(`Não foi possível recuperar a url para o webservice NFSe: ${metodo} no ambiente ${ambiente}`);
+        }
+        return url;
+    }
     /**
      * Retorna a url correta do webservice
      */
     getWebServiceUrl(metodo, ambienteNacional = false, versao = "", mod = "NFe") {
+        // Detecta se é NFSe
+        const isNFSe = metodo.startsWith('NFSe_');
+        if (isNFSe) {
+            const nfseUrls = NFSeServicosUrl;
+            const ambiente = this.environment.config.nfe.ambiente === 1 ? 'P' : 'H';
+            const chave = `NFSe_Nacional_${ambiente}`; // Nacional = ADN (Ambiente de Dados Nacional)
+            const url = nfseUrls[chave] && nfseUrls[chave][metodo];
+            if (!url) {
+                throw new Error(`Não foi possível recuperar a url para o webservice NFSe: ${metodo} no ambiente ${ambiente}`);
+            }
+            return url;
+        }
         // Detecta se é CTe
         const isCTe = metodo.startsWith('CTe');
         if (isCTe) {
@@ -2751,7 +3082,36 @@ class Utility {
         const responseInJson = this.xmlParser.convertXmlToJson(data, metodo);
         // Salva XML de retorno
         this.salvaRetorno(data, responseInJson, metodo, name);
-        // Busca todos os xMotivo no objeto
+        // Códigos de status de sucesso/processamento válidos
+        const codigosValidos = [
+            100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,
+            124, 128, 135, 136, 137, 138, 139, 140, 142, 150, 151
+        ];
+        // Busca o cStat no retorno
+        const cStat = this.findInObj(responseInJson, 'cStat');
+        // cStat pode ser: string, number, ou array de strings/numbers
+        let cStatNumber = null;
+        if (cStat !== undefined && cStat !== null) {
+            if (Array.isArray(cStat)) {
+                // Se for array, pega o primeiro elemento
+                cStatNumber = parseInt(String(cStat[0]), 10);
+            }
+            else {
+                // Se for string ou number direto
+                cStatNumber = parseInt(String(cStat), 10);
+            }
+        }
+        // Se existe cStat e não está na lista de códigos válidos, é rejeição
+        if (cStatNumber && !codigosValidos.includes(cStatNumber)) {
+            const xMotivo = this.findInObj(responseInJson, 'xMotivo');
+            let mensagemErro = `Rejeição com código ${cStatNumber}`;
+            if (xMotivo) {
+                // Se xMotivo for array, pega o primeiro elemento; senão, usa diretamente
+                mensagemErro = Array.isArray(xMotivo) ? xMotivo[0] : xMotivo;
+            }
+            throw new Error(mensagemErro);
+        }
+        // Busca todos os xMotivo no objeto (verificação adicional)
         const allXMotivos = this.findAllInObj(responseInJson, 'xMotivo');
         // Verifica se algum xMotivo contém "Rejeição" ou "Rejeicao"
         for (const xMotivo of allXMotivos) {
@@ -2844,6 +3204,30 @@ class Utility {
             }
         }
     }
+    /**
+     * Gera o hashCSRT conforme documentação da SEFAZ
+     *
+     * O hash é gerado a partir da concatenação do CSRT da empresa com a chave de acesso da NF-e/NFC-e.
+     * Utiliza o algoritmo SHA-1 para a geração do hash.
+     *
+     * @param csrt - Código de Segurança do Responsável Técnico (16 a 36 bytes alfanumérico)
+     * @param chaveAcesso - Chave de acesso da NF-e/NFC-e (44 dígitos)
+     * @returns Hash em Base64 com 28 caracteres
+     *
+     * @example
+     * // Exemplo de uso:
+     * const hashCSRT = utility.gerarHashCSRT('G8063VRTNDMO886SFNK5LDUDEI24XJ22YIPO', '41180678393592000146558900000006041028190697');
+     * // Resultado: aWv6LeEM4X6u4+qBI2OYZ8grigw=
+     */
+    gerarHashCSRT(csrt, chaveAcesso) {
+        // Passo 1: Concatenar o CSRT com a chave de acesso
+        const concatenacao = csrt + chaveAcesso;
+        // Passo 2: Aplicar o algoritmo SHA-1 sobre o resultado da concatenação
+        const sha1Hash = crypto.createHash('sha1').update(concatenacao).digest();
+        // Passo 3: Converter o resultado para Base64 (resulta em 28 caracteres)
+        const hashBase64 = sha1Hash.toString('base64');
+        return hashBase64;
+    }
 }
 
 /*
@@ -3272,6 +3656,22 @@ const mountICMS = (icms) => {
     return {};
 };
 
+/*
+ * This file is part of NFeWizard-io.
+ *
+ * NFeWizard-io 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.
+ *
+ * NFeWizard-io 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 NFeWizard-io. If not, see <https://www.gnu.org/licenses/>.
+ */
 class AxiosHttpClient {
     create(config) {
         return axios.create({
@@ -3282,6 +3682,22 @@ class AxiosHttpClient {
     }
 }
 
+/*
+ * This file is part of NFeWizard-io.
+ *
+ * NFeWizard-io 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.
+ *
+ * NFeWizard-io 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 NFeWizard-io. If not, see <https://www.gnu.org/licenses/>.
+ */
 class HttpClientBuilder {
     constructor(config, agent, httpClient) {
         this.config = config;
@@ -3309,6 +3725,22 @@ class HttpClientBuilder {
     }
 }
 
+/*
+ * This file is part of NFeWizard-io.
+ *
+ * NFeWizard-io 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.
+ *
+ * NFeWizard-io 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 NFeWizard-io. If not, see <https://www.gnu.org/licenses/>.
+ */
 class ValidateEnvironment {
     checkRequiredSettings(config) {
         logger.info('Verificando parâmetros de inicialização', {
@@ -3384,6 +3816,22 @@ class ValidateEnvironment {
     }
 }
 
+/*
+ * This file is part of NFeWizard-io.
+ *
+ * NFeWizard-io 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.
+ *
+ * NFeWizard-io 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 NFeWizard-io. If not, see <https://www.gnu.org/licenses/>.
+ */
 const baseDir = path.dirname(fileURLToPath(import.meta.url));
 // From dist/ to package root, then to resources/certs
 const dir = path.join(baseDir, '../resources/certs');
@@ -3627,5 +4075,5 @@ class Environment {
     }
 }
 
-export { AxiosHttpClient, BaseNFE, Environment, GerarConsulta, HttpClientBuilder, JsonArrayTransport, LoadCertificate, SaveFiles, Utility, ValidaCPFCNPJ, ValidateEnvironment, XmlBuilder, XmlParser, getCodIBGE, getDesTipoPag, getSchema, logger, mountCOFINS, mountICMS, mountPIS };
+export { AxiosHttpClient, BaseNFE, BaseNFSe, Environment, GerarConsulta, HttpClientBuilder, JsonArrayTransport, LoadCertificate, SaveFiles, Utility, ValidaCPFCNPJ, ValidateEnvironment, XmlBuilder, XmlParser, getCodIBGE, getDesTipoPag, getSchema, logger, mountCOFINS, mountICMS, mountPIS };
 //# sourceMappingURL=index.mjs.map