@treeunfe/nfe 1.0.5

package/src/operations/NFEDistribuicaoDFe/util/DistribuicaoHandler.ts

@@ -0,0 +1,150 @@
+/*
+ * 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/>.
+ */
+import { Environment, Utility, XmlParser } from '@treeunfe/shared';
+import { GenericObject } from '@treeunfe/types';
+import { AxiosResponse } from 'axios';
+import pako from 'pako';
+import xml2js from 'xml2js';
+
+class DistribuicaoHandler {
+    environment: Environment;
+    utility: Utility;
+    metodo: string;
+    constructor(environment: Environment, utility: Utility, metodo: string) {
+        this.utility = utility;
+        this.environment = environment;
+        this.metodo = metodo;
+    }
+
+    /**
+     * Métodos para tratativas do DistribuicaoDFe
+     */
+
+    protected salvaArquivos(XMLDistribuicaoInJson: GenericObject, XMLDistribuicao: string, chNFe: string): void {
+        const { pathXMLDistribuicao, baixarXMLDistribuicao, armazenarRetornoEmJSON } = this.environment.config;
+
+        if (baixarXMLDistribuicao) {
+            this.utility.salvaXML({
+                data: XMLDistribuicao,
+                fileName: chNFe,
+                metodo: this.metodo,
+                path: pathXMLDistribuicao,
+            });
+
+            if (armazenarRetornoEmJSON) {
+                this.utility.salvaJSON({
+                    data: XMLDistribuicaoInJson,
+                    fileName: chNFe,
+                    metodo: this.metodo,
+                    path: pathXMLDistribuicao,
+                });
+            }
+        }
+    }
+
+    deCompressDFeXML(loteDistDFeInt: AxiosResponse<any, any>, metodo: string, _xmlConsulta: string) {
+        try {
+            const json = new XmlParser()
+            const files: string[] = [];
+            xml2js.parseString(loteDistDFeInt, (err, result) => {
+                if (err) {
+                    throw new Error(`Erro ao descomprimir o XML: ${err}`);
+                }
+
+                const docZips = this.utility.findInObj(result, 'docZip');
+                docZips.forEach((docZip: any) => {
+                    const xmlString = this.decodeDocZip(docZip);
+                    const cleanedXml = this.removeSignatureTag(xmlString);
+
+                    const parsedResult = this.parseXml(cleanedXml);
+                    if (!parsedResult) return;
+
+                    let chNFe = this.getChNFe(parsedResult);
+                    let tipo = this.getTipo(parsedResult);
+                    const nsu = docZip['$'].NSU;
+
+                    if (parsedResult['procEventoNFe']) {
+                        const tpEvento = this.utility.findInObj(parsedResult, 'tpEvento');
+                        chNFe = `${chNFe}-event-${tpEvento}`;
+                        tipo = 'event';
+                    }
+
+                    const xmlDistribuicaoInJson = json.convertXmlToJson(cleanedXml, `${metodo}_${tipo}`, nsu);
+                    this.handleResponse(xmlDistribuicaoInJson, cleanedXml, chNFe);
+                    files.push(chNFe);
+                });
+            });
+            return files;
+        } catch (error: any) {
+            throw new Error(error.message);
+        }
+    }
+
+    decodeDocZip(docZip: any) {
+        const base64String = docZip['_'];
+        let binaryString = atob(base64String);
+        let bytes = new Uint8Array(binaryString.length);
+        for (let i = 0; i < binaryString.length; i++) {
+            bytes[i] = binaryString.charCodeAt(i);
+        }
+        let decompressedData = pako.inflate(bytes);
+        return new TextDecoder("utf-8").decode(decompressedData);
+    }
+
+    removeSignatureTag(xmlString: string) {
+        return xmlString.replace(/<Signature.*?<\/Signature>/gs, '');
+    }
+
+    parseXml(xmlString: string) {
+        let parsedResult;
+        xml2js.parseString(xmlString, (err, result) => {
+            if (err) {
+                console.error('Erro ao parsear o XML decomprimido:', err);
+                parsedResult = null;
+            } else {
+                parsedResult = result;
+            }
+        });
+        return parsedResult;
+    }
+
+    getChNFe(parsedResult: GenericObject) {
+        return this.utility.findInObj(parsedResult, 'chNFe');
+    }
+
+    getTipo(parsedResult: GenericObject) {
+        if (this.utility.findInObj(parsedResult, 'resNFe')) {
+            return 'res';
+        } else if (parsedResult['procEventoNFe']) {
+            return 'event';
+        }
+        return 'proc';
+    }
+
+    handleResponse(XMLDistribuicaoInJson: GenericObject, XMLDistribuicao: string, chNFe: string) {
+        // Gera erro em caso de Rejeição
+        const xMotivo = this.utility.findInObj(XMLDistribuicaoInJson, 'xMotivo')
+        if (xMotivo && (xMotivo.includes('Rejeição') || xMotivo.includes('Rejeicao'))) {
+            throw new Error(XMLDistribuicaoInJson.xMotivo)
+        }
+
+        this.salvaArquivos(XMLDistribuicaoInJson, XMLDistribuicao, chNFe)
+    }
+
+}
+
+export default DistribuicaoHandler;

package/src/operations/NFEInutilizacao/NFEInutilizacao.ts

@@ -0,0 +1,30 @@
+/*
+ * 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/>.
+ */
+import { NFEInutilizacaoServiceImpl } from '@treeunfe/types/interfaces';
+
+class NFEInutilizacao implements NFEInutilizacaoServiceImpl {
+    nfeInutilizacaoService: NFEInutilizacaoServiceImpl;
+    constructor(nfeInutilizacaoService: NFEInutilizacaoServiceImpl) {
+        this.nfeInutilizacaoService = nfeInutilizacaoService;
+    }
+
+    async Exec(data?: any): Promise<any> {
+        return await this.nfeInutilizacaoService.Exec(data);
+    }
+
+}
+export default NFEInutilizacao;

package/src/operations/NFERecepcaoEvento/NFECancelamento.ts

@@ -0,0 +1,31 @@
+/*
+ * 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/>.
+ */
+import { NFERecepcaoEventoServiceImpl } from '@treeunfe/types/interfaces';
+
+class NFECancelamento implements NFERecepcaoEventoServiceImpl {
+    nfeCancelamentoServiceService: NFERecepcaoEventoServiceImpl;
+    constructor(nfeCancelamentoServiceService: NFERecepcaoEventoServiceImpl) {
+        this.nfeCancelamentoServiceService = nfeCancelamentoServiceService;
+    }
+
+    async Exec(data?: any): Promise<any> {
+        return await this.nfeCancelamentoServiceService.Exec(data);
+    }
+}
+
+
+export default NFECancelamento;

package/src/operations/NFERecepcaoEvento/NFECartaDeCorrecao.ts

@@ -0,0 +1,31 @@
+/*
+ * 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/>.
+ */
+import { NFERecepcaoEventoServiceImpl } from '@treeunfe/types/interfaces/nfe';
+
+
+class NFECartaDeCorrecao implements NFERecepcaoEventoServiceImpl {
+    nfeCartaDeCorrecaoServiceService: NFERecepcaoEventoServiceImpl;
+    constructor(nfeCartaDeCorrecaoServiceService: NFERecepcaoEventoServiceImpl) {
+        this.nfeCartaDeCorrecaoServiceService = nfeCartaDeCorrecaoServiceService;
+    }
+
+    async Exec(data?: any): Promise<any> {
+        return await this.nfeCartaDeCorrecaoServiceService.Exec(data);
+    }
+}
+
+export default NFECartaDeCorrecao;

package/src/operations/NFERecepcaoEvento/NFECienciaDaOperacao.ts

@@ -0,0 +1,30 @@
+/*
+ * 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/>.
+ */
+import { NFERecepcaoEventoServiceImpl } from '@treeunfe/types/interfaces';
+
+class NFECienciaDaOperacao implements NFERecepcaoEventoServiceImpl {
+    nfeCienciaDaOperacaoServiceService: NFERecepcaoEventoServiceImpl;
+    constructor(nfeCienciaDaOperacaoServiceService: NFERecepcaoEventoServiceImpl) {
+        this.nfeCienciaDaOperacaoServiceService = nfeCienciaDaOperacaoServiceService;
+    }
+
+    async Exec(data?: any): Promise<any> {
+        return await this.nfeCienciaDaOperacaoServiceService.Exec(data);
+    }
+}
+
+export default NFECienciaDaOperacao;

package/src/operations/NFERecepcaoEvento/NFEConfirmacaoDaOperacao.ts

@@ -0,0 +1,30 @@
+/*
+ * 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/>.
+ */
+import { NFERecepcaoEventoServiceImpl } from '@treeunfe/types/interfaces/nfe';
+
+class NFEConfirmacaoDaOperacao implements NFERecepcaoEventoServiceImpl {
+    nfeConfirmacaoDaOperacaoServiceService: NFERecepcaoEventoServiceImpl;
+    constructor(nfeConfirmacaoDaOperacaoServiceService: NFERecepcaoEventoServiceImpl) {
+        this.nfeConfirmacaoDaOperacaoServiceService = nfeConfirmacaoDaOperacaoServiceService;
+    }
+
+    async Exec(data?: any): Promise<any> {
+        return await this.nfeConfirmacaoDaOperacaoServiceService.Exec(data);
+    }
+}
+
+export default NFEConfirmacaoDaOperacao;

package/src/operations/NFERecepcaoEvento/NFEDesconhecimentoDaOperacao.ts

@@ -0,0 +1,30 @@
+/*
+ * 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/>.
+ */
+import { NFERecepcaoEventoServiceImpl } from '@treeunfe/types/interfaces';
+
+class NFEDesconhecimentoDaOperacao implements NFERecepcaoEventoServiceImpl {
+    nfeDesconhecimentoDaOperacaoServiceService: NFERecepcaoEventoServiceImpl;
+    constructor(nfeDesconhecimentoDaOperacaoServiceService: NFERecepcaoEventoServiceImpl) {
+        this.nfeDesconhecimentoDaOperacaoServiceService = nfeDesconhecimentoDaOperacaoServiceService;
+    }
+
+    async Exec(data?: any): Promise<any> {
+        return await this.nfeDesconhecimentoDaOperacaoServiceService.Exec(data);
+    }
+}
+
+export default NFEDesconhecimentoDaOperacao;

package/src/operations/NFERecepcaoEvento/NFEEpec.ts

@@ -0,0 +1,29 @@
+/*
+ * 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/>.
+ */
+import { NFERecepcaoEventoServiceImpl } from '@treeunfe/types/interfaces';
+
+class NFEEpec implements NFERecepcaoEventoServiceImpl {
+    nfeEpecServiceService: NFERecepcaoEventoServiceImpl;
+    constructor(nfeEpecServiceService: NFERecepcaoEventoServiceImpl) {
+        this.nfeEpecServiceService = nfeEpecServiceService;
+    }
+
+    async Exec(data?: any): Promise<any> {
+        return await this.nfeEpecServiceService.Exec(data);
+    }
+}
+export default NFEEpec;

package/src/operations/NFERecepcaoEvento/NFEOperacaoNaoRealizada.ts

@@ -0,0 +1,30 @@
+/*
+ * 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/>.
+ */
+import { NFERecepcaoEventoServiceImpl } from '@treeunfe/types/interfaces';
+
+class NFEOperacaoNaoRealizada implements NFERecepcaoEventoServiceImpl {
+    nfeOperacaoNaoRealizadaServiceService: NFERecepcaoEventoServiceImpl;
+    constructor(nfeOperacaoNaoRealizadaServiceService: NFERecepcaoEventoServiceImpl) {
+        this.nfeOperacaoNaoRealizadaServiceService = nfeOperacaoNaoRealizadaServiceService;
+    }
+
+    async Exec(data?: any): Promise<any> {
+        return await this.nfeOperacaoNaoRealizadaServiceService.Exec(data);
+    }
+}
+
+export default NFEOperacaoNaoRealizada;

package/src/operations/NFERecepcaoEvento/NFERecepcaoEvento.ts

@@ -0,0 +1,30 @@
+/*
+ * 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/>.
+ */
+import { NFERecepcaoEventoServiceImpl } from '@treeunfe/types/interfaces';
+
+class NFERecepcaoEvento implements NFERecepcaoEventoServiceImpl {
+    nfeRecepcaoEventoService: NFERecepcaoEventoServiceImpl;
+    constructor(nfeRecepcaoEventoService: NFERecepcaoEventoServiceImpl) {
+        this.nfeRecepcaoEventoService = nfeRecepcaoEventoService;
+    }
+
+    async Exec(data?: any): Promise<any> {
+        return await this.nfeRecepcaoEventoService.Exec(data);
+    }
+}
+
+export default NFERecepcaoEvento;

package/src/operations/NFERetornoAutorizacao/NFERetornoAutorizacao.ts

@@ -0,0 +1,41 @@
+/*
+ * 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/>.
+ */
+import { NFERetornoAutorizacaoServiceImpl } from '@treeunfe/types/interfaces';
+import { ProtNFe } from '@treeunfe/types/nfe';
+
+class NFERetornoAutorizacao implements NFERetornoAutorizacaoServiceImpl {
+    nfeRetornoAutorizacaoService: NFERetornoAutorizacaoServiceImpl;
+    constructor(nfeRetornoAutorizacaoService: NFERetornoAutorizacaoServiceImpl) {
+        this.nfeRetornoAutorizacaoService = nfeRetornoAutorizacaoService;
+    }
+
+    async getXmlRetorno(data: {
+        tipoEmissao: number;
+        nRec?: string;
+        protNFe?: ProtNFe[];
+        xmlNFe: string[];
+    }): Promise<{
+        success: boolean;
+        message: any;
+        data: string[];
+    }> {
+        return await this.nfeRetornoAutorizacaoService.getXmlRetorno(data);
+    }
+
+}
+
+export default NFERetornoAutorizacao;

package/src/operations/NFEStatusServico/NFEStatusServico.ts

@@ -0,0 +1,31 @@
+/*
+ * 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/>.
+ */
+import { NFEStatusServicoServiceImpl } from '@treeunfe/types/interfaces';
+
+class NFEStatusServico implements NFEStatusServicoServiceImpl {
+    nfeStatusServicoService: NFEStatusServicoServiceImpl;
+    constructor(nfeStatusServicoService: NFEStatusServicoServiceImpl) {
+        this.nfeStatusServicoService = nfeStatusServicoService;
+    }
+
+    async Exec(data?: any): Promise<any> {
+        return await this.nfeStatusServicoService.Exec(data);
+    }
+
+}
+
+export default NFEStatusServico;

package/src/operations/index.ts

@@ -0,0 +1,34 @@
+/*
+ * 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/>.
+ */
+
+export { default as NFEAutorizacao } from './NFEAutorizacao/NFEAutorizacao';
+export { default as NFEConsultaProtocolo } from './NFEConsultaProtocolo/NFEconsultaProtocolo';
+export { default as NFEDistribuicaoDFe } from './NFEDistribuicaoDFe/NFEDistribuicaoDFe';
+export { default as NFEDistribuicaoDFePorChave } from './NFEDistribuicaoDFe/NFEDistribuicaoDFePorChave';
+export { default as NFEDistribuicaoDFePorNSU } from './NFEDistribuicaoDFe/NFEDistribuicaoDFePorNSU';
+export { default as NFEDistribuicaoDFePorUltNSU } from './NFEDistribuicaoDFe/NFEDistribuicaoDFePorUltNSU';
+export { default as NFEInutilizacao } from './NFEInutilizacao/NFEInutilizacao';
+export { default as NFERetornoAutorizacao } from './NFERetornoAutorizacao/NFERetornoAutorizacao';
+export { default as NFEStatusServico } from './NFEStatusServico/NFEStatusServico';
+export { default as NFERecepcaoEvento } from './NFERecepcaoEvento/NFERecepcaoEvento';
+export { default as NFECancelamento } from './NFERecepcaoEvento/NFECancelamento';
+export { default as NFECartaDeCorrecao } from './NFERecepcaoEvento/NFECartaDeCorrecao';
+export { default as NFECienciaDaOperacao } from './NFERecepcaoEvento/NFECienciaDaOperacao';
+export { default as NFEConfirmacaoDaOperacao } from './NFERecepcaoEvento/NFEConfirmacaoDaOperacao';
+export { default as NFEDesconhecimentoDaOperacao } from './NFERecepcaoEvento/NFEDesconhecimentoDaOperacao';
+export { default as NFEEpec } from './NFERecepcaoEvento/NFEEpec';
+export { default as NFEOperacaoNaoRealizada } from './NFERecepcaoEvento/NFEOperacaoNaoRealizada';