node-sped-nfe 1.1.4 → 1.1.6

package/dist/utils/extras.d.ts

@@ -1,4 +1,6 @@
 declare const cUF2UF: any, UF2cUF: any;
 declare const xml2json: (xml: string) => Promise<object>;
 declare const json2xml: (obj: object) => Promise<string>;
-export { cUF2UF, UF2cUF, json2xml, xml2json };
+declare const formatData: (dataUsr?: Date) => string;
+declare const docZip: (xml: string, retorno?: string) => Promise<unknown>;
+export { cUF2UF, UF2cUF, json2xml, xml2json, formatData, docZip };

package/dist/utils/extras.js

@@ -1,4 +1,6 @@
 import { XMLParser, XMLBuilder } from "fast-xml-parser";
+import { gunzipSync } from 'zlib'; // ou zlibSync
+import { Buffer } from 'buffer';
 const cUF2UF = {
     "11": "RO",
     "12": "AC",
@@ -292,4 +294,50 @@ const json2xml = (obj) => {
         resvol(XMLBuil.build(obj));
     });
 };
-export { cUF2UF, UF2cUF, json2xml, xml2json };
+const formatData = (dataUsr = new Date()) => {
+    const ano = dataUsr.getFullYear();
+    const mes = String(dataUsr.getMonth() + 1).padStart(2, '0'); // Adiciona 1 porque os meses começam do 0
+    const dia = String(dataUsr.getDate()).padStart(2, '0');
+    const horas = String(dataUsr.getHours()).padStart(2, '0');
+    const minutos = String(dataUsr.getMinutes()).padStart(2, '0');
+    const segundos = String(dataUsr.getSeconds()).padStart(2, '0');
+    const fusoHorario = -dataUsr.getTimezoneOffset() / 60; // Obtém o fuso horário em horas
+    const formatoISO = `${ano}-${mes}-${dia}T${horas}:${minutos}:${segundos}${fusoHorario >= 0 ? '+' : '-'}${String(Math.abs(fusoHorario)).padStart(2, '0')}:00`;
+    return formatoISO;
+};
+const docZip = async (xml, retorno = "original") => {
+    return new Promise(async (resolve, reject) => {
+        if (typeof retorno == "undefined")
+            retorno = "original";
+        const decodeDocZipToXml = (docZipBase64) => {
+            // 1. Converte base64 para buffer
+            const zippedBuffer = Buffer.from(docZipBase64, 'base64');
+            // 2. Descomprime com gzip
+            const xmlBuffer = gunzipSync(zippedBuffer);
+            // 3. Converte para string UTF-8
+            return xmlBuffer.toString('utf8');
+        };
+        const jXml = await xml2json(xml);
+        try {
+            var docZips = jXml["soap:Envelope"]["soap:Body"]["nfeDistDFeInteresseResponse"]["nfeDistDFeInteresseResult"]["retDistDFeInt"];
+            if (typeof docZips['loteDistDFeInt'] == "undefined")
+                return resolve([]);
+            docZips = docZips["loteDistDFeInt"]['docZip'];
+            if (!Array.isArray(docZips))
+                docZips = [docZips];
+            for (const doc of docZips) {
+                doc['xml'] = decodeDocZipToXml(doc['#text']);
+                doc['NSU'] = doc['@NSU'];
+                doc['schema'] = doc['@schema'];
+                delete doc['#text'];
+                delete doc['@NSU'];
+                delete doc['@schema'];
+            }
+            resolve(docZips);
+        }
+        catch (error) {
+            reject(error);
+        }
+    });
+};
+export { cUF2UF, UF2cUF, json2xml, xml2json, formatData, docZip };

package/dist/utils/tools.d.ts

@@ -10,6 +10,8 @@ declare class Tools {
         versao: string;
         timeout: number;
         openssl: null;
+        CPF: string;
+        CNPJ: string;
     }, certificado?: {
         pfx: string;
         senha: string;
@@ -20,6 +22,18 @@ declare class Tools {
     json2xml(obj: object): Promise<string>;
     getCertificado(): Promise<object>;
     consultarNFe(chNFe: string): Promise<string>;
+    sefazEvento({ chNFe, tpEvento, nProt, justificativa, textoCorrecao, sequencial }: {
+        chNFe?: string | undefined;
+        tpEvento?: string | undefined;
+        nProt?: string | undefined;
+        justificativa?: string | undefined;
+        textoCorrecao?: string | undefined;
+        sequencial?: number | undefined;
+    }): Promise<string>;
+    sefazDistDFe({ ultNSU }: {
+        ultNSU?: string;
+    }): Promise<string>;
     sefazStatus(): Promise<string>;
+    validarNFe(xml: string): Promise<any>;
 }
 export { Tools };

package/dist/utils/tools.js

@@ -9,8 +9,8 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _Tools_instances, _Tools_cert, _Tools_xmlTools, _Tools_pem, _Tools_config, _Tools_gerarQRCodeNFCe, _Tools_xmlValido, _Tools_certTools;
-import { XMLParser, XMLBuilder } from "fast-xml-parser";
+var _Tools_instances, _Tools_cert, _Tools_pem, _Tools_config, _Tools_getSignature, _Tools_gerarQRCodeNFCe, _Tools_descEvento, _Tools_xmlValido, _Tools_certTools;
+import { XMLBuilder } from "fast-xml-parser";
 import https from "https";
 import { spawnSync } from "child_process";
 import tmp from "tmp";
@@ -20,17 +20,14 @@ import fs from "fs";
 import path from 'path';
 import { fileURLToPath } from 'url';
 import pem from 'pem';
-import { cUF2UF } from "./extras.js";
+import { cUF2UF, json2xml, xml2json, UF2cUF } from "./extras.js";
+import { SignedXml } from 'xml-crypto';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 class Tools {
-    constructor(config = { mod: "", xmllint: 'xmllint', UF: '', tpAmb: 2, CSC: "", CSCid: "", versao: "4.00", timeout: 30, openssl: null }, certificado = { pfx: "", senha: "" }) {
+    constructor(config = { mod: "", xmllint: 'xmllint', UF: '', tpAmb: 2, CSC: "", CSCid: "", versao: "4.00", timeout: 30, openssl: null, CPF: "", CNPJ: "" }, certificado = { pfx: "", senha: "" }) {
         _Tools_instances.add(this);
         _Tools_cert.set(this, void 0);
-        _Tools_xmlTools.set(this, {
-            XMLBuilder: {},
-            XMLParser: {}
-        });
         _Tools_pem.set(this, {
             key: "", // A chave privada extraída do PKCS#12, em formato PEM
             cert: "", // O certificado extraído, em formato PEM
@@ -55,15 +52,6 @@ class Tools {
         //Configurar certificado
         __classPrivateFieldSet(this, _Tools_config, config, "f");
         __classPrivateFieldSet(this, _Tools_cert, certificado, "f");
-        __classPrivateFieldGet(this, _Tools_xmlTools, "f").XMLBuilder = new XMLBuilder({
-            ignoreAttributes: false,
-            attributeNamePrefix: "@",
-        });
-        __classPrivateFieldGet(this, _Tools_xmlTools, "f").XMLParser = new XMLParser({
-            ignoreAttributes: false,
-            attributeNamePrefix: "@",
-            parseTagValue: false, // Evita conversão automática de valores
-        });
     }
     sefazEnviaLote(xml, data = { idLote: 1, indSinc: 0, compactar: false }) {
         return new Promise(async (resvol, reject) => {
@@ -107,7 +95,7 @@ class Tools {
                         },
                         rejectUnauthorized: false
                     },
-                    ...__classPrivateFieldGet(this, _Tools_pem, "f")
+                    ...await __classPrivateFieldGet(this, _Tools_instances, "m", _Tools_certTools).call(this)
                 }, (res) => {
                     let data = '';
                     res.on('data', (chunk) => {
@@ -139,71 +127,33 @@ class Tools {
         return new Promise(async (resvol, reject) => {
             if (data.tag === undefined)
                 data.tag = "infNFe";
-            //Obter a tag que ira ser assinada
-            let xml = await this.xml2json(xmlJSON);
-            let tempPem = await __classPrivateFieldGet(this, _Tools_instances, "m", _Tools_certTools).call(this);
-            const sign = crypto.createSign('RSA-SHA1'); // Correção: Alterado para RSA-SHA1
-            let signedInfo = {
-                "SignedInfo": {
-                    "@xmlns": "http://www.w3.org/2000/09/xmldsig#",
-                    "CanonicalizationMethod": {
-                        "@Algorithm": "http://www.w3.org/TR/2001/REC-xml-c14n-20010315"
-                    },
-                    "SignatureMethod": {
-                        "@Algorithm": "http://www.w3.org/2000/09/xmldsig#rsa-sha1" // Mantém SHA1
-                    },
-                    "Reference": {
-                        "@URI": `#${xml.NFe.infNFe['@Id']}`,
-                        "Transforms": {
-                            "Transform": [
-                                {
-                                    "@Algorithm": "http://www.w3.org/2000/09/xmldsig#enveloped-signature"
-                                },
-                                {
-                                    "@Algorithm": "http://www.w3.org/TR/2001/REC-xml-c14n-20010315"
-                                },
-                            ]
-                        },
-                        "DigestMethod": {
-                            "@Algorithm": "http://www.w3.org/2000/09/xmldsig#sha1" // Mantém SHA1
-                        },
-                        "DigestValue": crypto.createHash('sha1').update(await this.json2xml({ infNFe: xml.NFe.infNFe }), 'utf8') // Mantém Hash SHA1
-                            .digest('base64')
-                    }
-                }
-            };
-            sign.update(await this.json2xml(signedInfo), 'utf8');
-            xml.NFe.Signature = {
-                ...signedInfo,
-                ...{
-                    "SignatureValue": sign.sign(tempPem.key, 'base64'),
-                    "KeyInfo": {
-                        "X509Data": {
-                            "X509Certificate": tempPem.cert.replace(/-----BEGIN CERTIFICATE-----/g, '').replace(/-----END CERTIFICATE-----/g, '').replace(/\r\n/g, '')
-                        }
-                    },
-                    "@xmlns": "http://www.w3.org/2000/09/xmldsig#"
+            var xml = await this.xml2json(xmlJSON);
+            if (data.tag == "infNFe") {
+                if (xml.NFe.infNFe.ide.mod == 65) {
+                    xml.NFe.infNFeSupl.qrCode = __classPrivateFieldGet(this, _Tools_instances, "m", _Tools_gerarQRCodeNFCe).call(this, xml.NFe, "2", __classPrivateFieldGet(this, _Tools_config, "f").CSCid, __classPrivateFieldGet(this, _Tools_config, "f").CSC);
                 }
-            };
-            if (xml.NFe.infNFe.ide.mod == 65) {
-                xml.NFe.infNFeSupl.qrCode = __classPrivateFieldGet(this, _Tools_instances, "m", _Tools_gerarQRCodeNFCe).call(this, xml.NFe, "2", __classPrivateFieldGet(this, _Tools_config, "f").CSCid, __classPrivateFieldGet(this, _Tools_config, "f").CSC);
+                xml.NFe = {
+                    ...xml.NFe,
+                    ...await xml2json(await __classPrivateFieldGet(this, _Tools_instances, "m", _Tools_getSignature).call(this, xmlJSON, data.tag))
+                };
             }
-            this.json2xml(xml).then(async (res) => {
-                __classPrivateFieldGet(this, _Tools_instances, "m", _Tools_xmlValido).call(this, res, `nfe_v${__classPrivateFieldGet(this, _Tools_config, "f").versao}`);
-                resvol(res);
-            }).catch(err => {
-                reject(err);
-            });
+            else if (data.tag == "infEvento") {
+                xml.envEvento.evento = {
+                    ...xml.envEvento.evento,
+                    ...(await xml2json(await __classPrivateFieldGet(this, _Tools_instances, "m", _Tools_getSignature).call(this, xmlJSON, data.tag)))
+                };
+            }
+            resvol(await json2xml(xml));
         });
     }
     async xml2json(xml) {
         return new Promise((resvol, reject) => {
-            resvol(__classPrivateFieldGet(this, _Tools_xmlTools, "f").XMLParser.parse(xml));
+            xml2json(xml).then(resvol).catch(reject);
         });
     }
     async json2xml(obj) {
         return new Promise((resvol, reject) => {
-            resvol(__classPrivateFieldGet(this, _Tools_xmlTools, "f").XMLBuilder.build(obj));
+            json2xml(obj).then(resvol).catch(reject);
         });
     }
     //Obter certificado 
@@ -247,10 +197,10 @@ class Tools {
                     attributeNamePrefix: "@"
                 });
                 // Validação do XML interno (opcional)
-                __classPrivateFieldGet(this, _Tools_instances, "m", _Tools_xmlValido).call(this, builder.build({ consSitNFe }), `consSitNFe_v${__classPrivateFieldGet(this, _Tools_config, "f").versao}`);
+                await __classPrivateFieldGet(this, _Tools_instances, "m", _Tools_xmlValido).call(this, builder.build({ consSitNFe }), `consSitNFe_v${__classPrivateFieldGet(this, _Tools_config, "f").versao}`).catch(reject);
+                ;
                 const xml = builder.build(xmlObj);
                 let tempUF = urlEventos(UF, __classPrivateFieldGet(this, _Tools_config, "f").versao);
-                console.log(tempUF);
                 const url = tempUF[`mod${mod}`][(__classPrivateFieldGet(this, _Tools_config, "f").tpAmb == 1 ? "producao" : "homologacao")].NFeConsultaProtocolo;
                 const req = https.request(url, {
                     method: 'POST',
@@ -281,6 +231,215 @@ class Tools {
             }
         });
     }
+    async sefazEvento({ chNFe = "", tpEvento = "", nProt = "", justificativa = "", textoCorrecao = "", sequencial = 1 }) {
+        return new Promise(async (resolve, reject) => {
+            try {
+                if (!chNFe)
+                    throw "sefazEvento({chNFe}) -> não definido!";
+                if (!tpEvento)
+                    throw "sefazEvento({tpEvento}) -> não definido!";
+                if (!__classPrivateFieldGet(this, _Tools_config, "f").CNPJ && !__classPrivateFieldGet(this, _Tools_config, "f").CPF)
+                    throw "new Tools({CNPJ|CPF}) -> não definido!";
+                const geradorLote = function () {
+                    const agora = new Date();
+                    const ano = agora.getFullYear().toString().slice(2); // Só os 2 últimos dígitos do ano
+                    const mes = String(agora.getMonth() + 1).padStart(2, '0');
+                    const dia = String(agora.getDate()).padStart(2, '0');
+                    const hora = String(agora.getHours()).padStart(2, '0');
+                    const minuto = String(agora.getMinutes()).padStart(2, '0');
+                    const segundo = String(agora.getSeconds()).padStart(2, '0');
+                    // Junta tudo
+                    let idLote = `${ano}${mes}${dia}${hora}${minuto}${segundo}`;
+                    // Se ainda tiver menos de 15 dígitos, adiciona um número aleatório no final
+                    while (idLote.length < 15) {
+                        idLote += Math.floor(Math.random() * 10); // Adiciona dígitos aleatórios
+                    }
+                    return idLote;
+                };
+                const tempUF = urlEventos(`AN`, __classPrivateFieldGet(this, _Tools_config, "f").versao);
+                let detEvento = {
+                    "@versao": "1.00",
+                    "descEvento": __classPrivateFieldGet(this, _Tools_instances, "m", _Tools_descEvento).call(this, `${tpEvento}`)
+                };
+                // Adicionar campos específicos por tipo de evento
+                if (tpEvento === "110111") { // Cancelamento
+                    if (!nProt)
+                        throw "sefazEvento({nProt}) obrigatório para Cancelamento!";
+                    if (!justificativa)
+                        throw "sefazEvento({justificativa}) obrigatório para Cancelamento!";
+                    detEvento["nProt"] = nProt;
+                    detEvento["xJust"] = justificativa;
+                }
+                else if (tpEvento === "110110") { // Carta de Correção
+                    if (!textoCorrecao)
+                        throw "sefazEvento({textoCorrecao}) obrigatório para Carta de Correção!";
+                    detEvento["xCorrecao"] = textoCorrecao;
+                    detEvento["xCondUso"] = "A carta de correção é disciplinada pelo § 1º-A do art. 7º do Convênio S/N, de 15 de dezembro de 1970...";
+                }
+                else if (tpEvento === "210240") { // Operação não realizada
+                    if (!justificativa)
+                        throw "sefazEvento({justificativa}) obrigatório para Operação não realizada!";
+                    detEvento["xJust"] = justificativa;
+                }
+                // Ciência (210210), Confirmação (210200), Desconhecimento (210220) não precisam de campos extras
+                const evento = {
+                    "envEvento": {
+                        "@xmlns": "http://www.portalfiscal.inf.br/nfe",
+                        "@versao": "1.00",
+                        "idLote": "250429141621528",
+                        "evento": {
+                            "@xmlns": "http://www.portalfiscal.inf.br/nfe",
+                            "@versao": "1.00",
+                            "infEvento": {
+                                "@Id": `ID${tpEvento}${chNFe}${sequencial.toString().padStart(2, '0')}`,
+                                "cOrgao": "91",
+                                "tpAmb": __classPrivateFieldGet(this, _Tools_config, "f").tpAmb,
+                                "CNPJ": __classPrivateFieldGet(this, _Tools_config, "f").CNPJ,
+                                "chNFe": chNFe,
+                                "dhEvento": "2025-04-29T14:16:21-03:00",
+                                "tpEvento": tpEvento,
+                                "nSeqEvento": sequencial,
+                                "verEvento": "1.00",
+                                "detEvento": detEvento
+                            }
+                        }
+                    }
+                };
+                let xmlSing = await json2xml(evento);
+                xmlSing = await this.xmlSign(xmlSing, { tag: "infEvento" }); //Assinado
+                fs.writeFileSync("testes/xmlEvento.xml", xmlSing, "utf8");
+                await __classPrivateFieldGet(this, _Tools_instances, "m", _Tools_xmlValido).call(this, xmlSing, `envEvento_v1.00`).catch(reject); //Validar corpo
+                xmlSing = await json2xml({
+                    "soap:Envelope": {
+                        "@xmlns:soap": "http://www.w3.org/2003/05/soap-envelope",
+                        "@xmlns:nfe": "http://www.portalfiscal.inf.br/nfe/wsdl/NFeRecepcaoEvento4",
+                        "soap:Body": {
+                            "nfe:nfeDadosMsg": await xml2json(xmlSing)
+                        }
+                    }
+                });
+                try {
+                    const req = https.request(tempUF[`mod${__classPrivateFieldGet(this, _Tools_config, "f").mod}`][(__classPrivateFieldGet(this, _Tools_config, "f").tpAmb == 1 ? "producao" : "homologacao")].NFeRecepcaoEvento, {
+                        ...{
+                            method: 'POST',
+                            headers: {
+                                'Content-Type': 'application/soap+xml; charset=utf-8',
+                                'Content-Length': xmlSing.length,
+                            },
+                            rejectUnauthorized: false,
+                        },
+                        ...await __classPrivateFieldGet(this, _Tools_instances, "m", _Tools_certTools).call(this)
+                    }, (res) => {
+                        let data = '';
+                        res.on('data', (chunk) => {
+                            data += chunk;
+                        });
+                        res.on('end', () => {
+                            resolve(data);
+                        });
+                    });
+                    req.setTimeout(__classPrivateFieldGet(this, _Tools_config, "f").timeout * 1000, () => {
+                        reject({
+                            name: 'TimeoutError',
+                            message: 'The operation was aborted due to timeout'
+                        });
+                        req.destroy(); // cancela a requisição
+                    });
+                    req.on('error', (erro) => {
+                        reject(erro);
+                    });
+                    req.write(xmlSing);
+                    req.end();
+                }
+                catch (erro) {
+                    reject(erro);
+                }
+            }
+            catch (erro) {
+                reject(erro);
+            }
+        });
+    }
+    async sefazDistDFe({ ultNSU = "000000000000000" }) {
+        return new Promise(async (resolve, reject) => {
+            try {
+                if (!__classPrivateFieldGet(this, _Tools_config, "f").CNPJ)
+                    throw "CNPJ não definido!";
+                if (__classPrivateFieldGet(this, _Tools_config, "f").CNPJ.length !== 14)
+                    throw "CNPJ inválido!";
+                // Gera o XML da consulta
+                // Prepara o SOAP
+                var xmlSing = await json2xml({
+                    "distDFeInt": {
+                        "@xmlns": "http://www.portalfiscal.inf.br/nfe",
+                        "@versao": "1.01",
+                        "tpAmb": 1, // 1 = produção, 2 = homologação
+                        "cUFAutor": UF2cUF[__classPrivateFieldGet(this, _Tools_config, "f").UF], // "AN" - Ambiente Nacional
+                        "CNPJ": __classPrivateFieldGet(this, _Tools_config, "f").CNPJ,
+                        "distNSU": {
+                            "ultNSU": `${ultNSU}`.padStart(15, '0')
+                        }
+                    }
+                });
+                await __classPrivateFieldGet(this, _Tools_instances, "m", _Tools_xmlValido).call(this, xmlSing, `distDFeInt_v1.01`).catch(reject); //Validar corpo
+                const tempUF = urlEventos(`AN`, __classPrivateFieldGet(this, _Tools_config, "f").versao);
+                xmlSing = await json2xml({
+                    "soap:Envelope": {
+                        "@xmlns:xsi": "http://www.w3.org/2001/XMLSchema-instance",
+                        "@xmlns:xsd": "http://www.w3.org/2001/XMLSchema",
+                        "@xmlns:soap": "http://www.w3.org/2003/05/soap-envelope",
+                        "soap:Body": {
+                            "nfeDistDFeInteresse": {
+                                "@xmlns": "http://www.portalfiscal.inf.br/nfe/wsdl/NFeDistribuicaoDFe",
+                                "nfeDadosMsg": {
+                                    ...{ "@xmlns": "http://www.portalfiscal.inf.br/nfe/wsdl/NFeDistribuicaoDFe" },
+                                    ...await xml2json(xmlSing)
+                                }
+                            }
+                        }
+                    }
+                });
+                // HTTPS Request
+                const req = https.request(tempUF[`mod${__classPrivateFieldGet(this, _Tools_config, "f").mod}`][(__classPrivateFieldGet(this, _Tools_config, "f").tpAmb == 1 ? "producao" : "homologacao")].NFeDistribuicaoDFe, {
+                    ...{
+                        method: 'POST',
+                        headers: {
+                            'Content-Type': 'application/soap+xml; charset=utf-8',
+                            'Content-Length': xmlSing.length,
+                        },
+                        rejectUnauthorized: false
+                    },
+                    ...await __classPrivateFieldGet(this, _Tools_instances, "m", _Tools_certTools).call(this)
+                }, (res) => {
+                    let data = '';
+                    res.on('data', (chunk) => {
+                        console.log(chunk);
+                        data += chunk;
+                    });
+                    res.on('end', () => {
+                        resolve(data);
+                    });
+                });
+                req.setTimeout(__classPrivateFieldGet(this, _Tools_config, "f").timeout * 1000, () => {
+                    reject({
+                        name: 'TimeoutError',
+                        message: 'The operation was aborted due to timeout'
+                    });
+                    req.destroy(); // cancela a requisição
+                });
+                req.on('error', (erro) => {
+                    reject(erro);
+                });
+                req.write(xmlSing);
+                req.end();
+                // Opcional: salvar a requisição para análise
+                fs.writeFileSync("testes/consultaDistribuicao.xml", xmlSing, "utf8");
+            }
+            catch (erro) {
+                reject(erro);
+            }
+        });
+    }
     //Consulta status sefaz
     async sefazStatus() {
         return new Promise(async (resvol, reject) => {
@@ -316,7 +475,7 @@ class Tools {
                     attributeNamePrefix: "@"
                 });
                 //Validação
-                __classPrivateFieldGet(this, _Tools_instances, "m", _Tools_xmlValido).call(this, tempBuild.build({ consStatServ }), `consStatServ_v${__classPrivateFieldGet(this, _Tools_config, "f").versao}`);
+                await __classPrivateFieldGet(this, _Tools_instances, "m", _Tools_xmlValido).call(this, tempBuild.build({ consStatServ }), `consStatServ_v${__classPrivateFieldGet(this, _Tools_config, "f").versao}`).catch(reject);
                 let tempUF = urlEventos(__classPrivateFieldGet(this, _Tools_config, "f").UF, __classPrivateFieldGet(this, _Tools_config, "f").versao);
                 let xml = tempBuild.build(xmlObj);
                 const req = https.request(tempUF[`mod${__classPrivateFieldGet(this, _Tools_config, "f").mod}`][(__classPrivateFieldGet(this, _Tools_config, "f").tpAmb == 1 ? "producao" : "homologacao")].NFeStatusServico, {
@@ -356,8 +515,48 @@ class Tools {
             }
         });
     }
+    async validarNFe(xml) {
+        return new Promise((resolve, reject) => {
+            __classPrivateFieldGet(this, _Tools_instances, "m", _Tools_xmlValido).call(this, xml, `nfe_v${__classPrivateFieldGet(this, _Tools_config, "f").versao}`).then(resolve).catch(reject);
+        });
+    }
 }
-_Tools_cert = new WeakMap(), _Tools_xmlTools = new WeakMap(), _Tools_pem = new WeakMap(), _Tools_config = new WeakMap(), _Tools_instances = new WeakSet(), _Tools_gerarQRCodeNFCe = function _Tools_gerarQRCodeNFCe(NFe, versaoQRCode = "2", idCSC, CSC) {
+_Tools_cert = new WeakMap(), _Tools_pem = new WeakMap(), _Tools_config = new WeakMap(), _Tools_instances = new WeakSet(), _Tools_getSignature = 
+//Responsavel por gerar assinatura
+async function _Tools_getSignature(xmlJSON, tag) {
+    return new Promise(async (resvol, reject) => {
+        let tempPem = await __classPrivateFieldGet(this, _Tools_instances, "m", _Tools_certTools).call(this);
+        const sig = new SignedXml({
+            privateKey: tempPem.key,
+            canonicalizationAlgorithm: 'http://www.w3.org/TR/2001/REC-xml-c14n-20010315',
+            signatureAlgorithm: 'http://www.w3.org/2000/09/xmldsig#rsa-sha1',
+            publicCert: tempPem.pem,
+            getKeyInfoContent: (args) => {
+                const cert = tempPem.cert
+                    .toString()
+                    .replace('-----BEGIN CERTIFICATE-----', '')
+                    .replace('-----END CERTIFICATE-----', '')
+                    .replace(/\r?\n|\r/g, '');
+                return `<X509Data><X509Certificate>${cert}</X509Certificate></X509Data>`;
+            }
+        });
+        sig.addReference({
+            xpath: `//*[local-name(.)='${tag}']`,
+            transforms: [
+                'http://www.w3.org/2000/09/xmldsig#enveloped-signature',
+                'http://www.w3.org/TR/2001/REC-xml-c14n-20010315'
+            ],
+            digestAlgorithm: 'http://www.w3.org/2000/09/xmldsig#sha1'
+        });
+        sig.computeSignature(xmlJSON, {
+            location: {
+                reference: `//*[local-name()='${tag}']`,
+                action: 'after' // <- insere DENTRO da tag <evento>
+            }
+        });
+        return resvol(sig.getSignatureXml());
+    });
+}, _Tools_gerarQRCodeNFCe = function _Tools_gerarQRCodeNFCe(NFe, versaoQRCode = "2", idCSC, CSC) {
     let s = '|', concat, hash;
     if (NFe.infNFe.ide.tpEmis == 1) {
         concat = [NFe.infNFe['@Id'].replace("NFe", ""), versaoQRCode, NFe.infNFe.ide.tpAmb, Number(idCSC)].join(s);
@@ -368,22 +567,38 @@ _Tools_cert = new WeakMap(), _Tools_xmlTools = new WeakMap(), _Tools_pem = new W
     }
     hash = crypto.createHash('sha1').update(concat + CSC).digest('hex');
     return NFe.infNFeSupl.qrCode + '?p=' + concat + s + hash;
+}, _Tools_descEvento = function _Tools_descEvento(tpEvento) {
+    const eventos = {
+        "110110": "Carta de Correcao",
+        "110111": "Cancelamento",
+        "210200": "Confirmacao da Operacao",
+        "210210": "Ciencia da Operacao",
+        "210220": "Desconhecimento da Operacao",
+        "210240": "Operacao nao Realizada"
+    };
+    return eventos[tpEvento] || "Evento";
 }, _Tools_xmlValido = 
 //Validar XML da NFe, somente apos assinar
 async function _Tools_xmlValido(xml, xsd) {
-    const xmlFile = tmp.fileSync({ mode: 0o644, prefix: 'xml-', postfix: '.xml' });
-    fs.writeFileSync(xmlFile.name, xml, { encoding: 'utf8' });
-    const schemaPath = path.resolve(__dirname, `../../schemas/${xsd}.xsd`);
-    const verif = spawnSync(__classPrivateFieldGet(this, _Tools_config, "f").xmllint, ['--noout', '--schema', schemaPath, xmlFile.name], { encoding: 'utf8' });
-    xmlFile.removeCallback();
-    // Aqui, usamos o operador de encadeamento opcional (?.)
-    if (verif.error) {
-        throw new Error("Biblioteca xmllint não encontrada!");
-    }
-    else if (!verif.stderr.includes(".xml validates")) {
-        throw new Error(verif.stderr);
-    }
-    return 1;
+    return new Promise((resolve, reject) => {
+        const xmlFile = tmp.fileSync({ mode: 0o644, prefix: 'xml-', postfix: '.xml' });
+        fs.writeFileSync(xmlFile.name, xml, { encoding: 'utf8' });
+        const schemaPath = path.resolve(__dirname, `../../schemas/PL_010_V1/${xsd}.xsd`);
+        const verif = spawnSync(__classPrivateFieldGet(this, _Tools_config, "f").xmllint, ['--noout', '--schema', schemaPath, xmlFile.name], { encoding: 'utf8' });
+        xmlFile.removeCallback();
+        // Aqui, usamos o operador de encadeamento opcional (?.)
+        if (verif.error) {
+            return reject("Biblioteca xmllint não encontrada!");
+        }
+        else if (!verif.stderr.includes(".xml validates")) {
+            return reject(verif.stderr.replace(/\/tmp\/[^:\s]+\.xml/g, '') // Remove os caminhos /tmp/*.xml
+                .replace(/\s{2,}/g, ' ') // Ajusta múltiplos espaços para um só
+                .trim()); // Remove espaços no começo e fim)
+        }
+        else {
+            resolve(true);
+        }
+    });
 }, _Tools_certTools = function _Tools_certTools() {
     return new Promise(async (resvol, reject) => {
         if (__classPrivateFieldGet(this, _Tools_pem, "f").key != "")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-sped-nfe",
-  "version": "1.1.4",
+  "version": "1.1.6",
   "author": "Kalmon V. Tavares",
   "type": "module",
   "main": "dist/index.js",
@@ -32,7 +32,6 @@
     "teste": "node testes/teste.js"
   },
   "devDependencies": {
-    "@types/axios": "^0.9.36",
     "@types/node": "^22.14.0",
     "@types/node-forge": "^1.3.11",
     "@types/pem": "^1.14.4",
@@ -41,10 +40,14 @@
     "typescript": "^5.0.0"
   },
   "dependencies": {
+    "@xmldom/xmldom": "^0.9.8",
     "crypto": "^1.0.1",
     "fast-xml-parser": "^4.5.1",
     "pem": "^1.14.8",
-    "tmp": "^0.2.3"
+    "tmp": "^0.2.3",
+    "xml-crypto": "^6.1.2",
+    "xmldom": "^0.6.0",
+    "zlib": "^1.0.5"
   },
   "repository": {
     "type": "git",