@nfewizard/shared 1.0.2 → 1.1.0

package/README.md

@@ -15,9 +15,55 @@ pnpm add @nfewizard/shared
 - ✅ **XmlBuilder** - Assinatura digital e geração de SOAP
 - ✅ **HttpClient** - Cliente HTTP configurado para SEFAZ
 - ✅ **LoadCertificate** - Carregamento de certificados A1
-- ✅ **SchemaLoader** - Validação XSD
+- ✅ **SchemaLoader** - Mapeamento de schemas XSD por operação fiscal
+- ✅ **NFE_SchemaValidate** - Validação de XML contra schema XSD com relatório humanizado
 - ✅ **Utilities** - Funções auxiliares (validações, formatações)
 
+## NFE_SchemaValidate
+
+Função pública que valida um XML fiscal contra o schema XSD oficial, disponível para uso direto ou via facade (`NFeWizard.NFE_SchemaValidate`, `NFSe.NFSe_SchemaValidate`).
+
+```typescript
+import { NFE_SchemaValidate, SchemaValidationResult } from '@nfewizard/shared';
+
+const result: SchemaValidationResult = await NFE_SchemaValidate(
+    xmlString,
+    'NFeAutorizacao',
+    { validator: 'validateSchemaJsBased' } // opcional
+);
+
+// result.success   — boolean
+// result.message   — mensagem-resumo humanizada
+// result.errors[]  — SchemaValidationIssue[]: { raw, humanized, element?, line?, column?, expected? }
+// result.report    — string multilinha estilo SEFAZ-RS
+// result.tableRows — Array pronto para console.table
+// result.schema    — arquivo XSD utilizado
+// result.metodo    — SchemaValidateMethod informado
+```
+
+### Métodos disponíveis (`SchemaValidateMethod`)
+
+| Valor | Schema XSD |
+|-------|-----------|
+| `'NFeAutorizacao'` / `'NFEAutorizacao'` | `enviNFe_v4.00.xsd` (envelope adicionado automaticamente se ausente) |
+| `'NFEStatusServico'` | `consStatServ_v4.00.xsd` |
+| `'NFEConsultaProtocolo'` | `consSitNFe_v4.00.xsd` |
+| `'RecepcaoEvento'` | `envEvento_v1.00.xsd` |
+| `'NFeDistribuicaoDFe'` | `distDFeInt_v1.01.xsd` |
+| `'NFEInutilizacao'` | `inutNFe_v4.00.xsd` |
+| `'NFERetAutorizacao'` | `consReciNFe_v4.00.xsd` |
+| `'CTeDistribuicaoDFe'` | `cte/distDFeInt_v1.00.xsd` |
+| `'NFSe_Autorizacao'` | `nfse/DPS_v1.01.xsd` |
+| `'NFSe_Consulta'` / `'NFSe_Distribuicao'` | `nfse/NFSe_v1.01.xsd` |
+| `'NFSe_Eventos'` | `nfse/pedRegEvento_v1.01.xsd` |
+| `'NFSe_ParametrosMunicipais'` | — (API REST, sem XSD) |
+
+### Seleção do validador
+
+1. `options.validator` — escolha explícita do caller.
+2. `options.environment.getConfig().lib?.useForSchemaValidation` — valor do config da lib.
+3. `'validateSchemaJsBased'` — padrão (sem JDK).
+
 ## Licença
 
 GPL-3.0

package/dist/index.cjs

@@ -456,6 +456,195 @@ class XmlParser {
         }
         return jsonBody;
     }
+    /**
+     * Converte um XML de envio (`enviNFe`) ou uma `NFe` solo em uma
+     * estrutura JSON compatível com o tipo `NFe` esperado pelos serviços
+     * de Autorização de NFe/NFCe (`{ idLote, indSinc, NFe }`).
+     *
+     * Formatos aceitos:
+     *  - Envelope `enviNFe` contendo uma ou mais `NFe`.
+     *  - `nfeProc` (XML autorizado) — extrai a `NFe` interna.
+     *  - `NFe` solo — empacota com defaults (`idLote=1`, `indSinc=1`).
+     *
+     * Defaults são aplicáveis somente para os campos do envelope; o
+     * conteúdo de `infNFe` não é alterado e segue o fluxo normal de
+     * geração/assinatura no service.
+     *
+     * @param xml String XML de entrada.
+     * @param overrides Permite sobrescrever `idLote`/`indSinc` quando o XML
+     *                  não contém envelope.
+     */
+    convertXmlEnvioNFeToJson(xml, overrides) {
+        logger.info('Convertendo XML de envio para JSON', {
+            context: 'XmlParser',
+            method: 'convertXmlEnvioNFeToJson',
+        });
+        const jsonData = this.parseNfeLikeXml(xml);
+        let envelope = this.findInObj(jsonData, 'enviNFe');
+        if (!envelope) {
+            const nfeProc = this.findInObj(jsonData, 'nfeProc');
+            const nfeNode = nfeProc ? this.findInObj(nfeProc, 'NFe') : this.findInObj(jsonData, 'NFe');
+            if (!nfeNode) {
+                throw new Error('XML inválido: não foi possível localizar `enviNFe` ou `NFe`.');
+            }
+            envelope = {
+                idLote: overrides?.idLote ?? '1',
+                indSinc: overrides?.indSinc ?? 1,
+                NFe: nfeNode,
+            };
+        }
+        // Normaliza CNPJ/CPF -> CNPJCPF nas NFe (formato esperado pela lib)
+        const nfeList = Array.isArray(envelope.NFe) ? envelope.NFe : [envelope.NFe];
+        nfeList.forEach((n) => this.normalizeNfeForLibFormat(n));
+        return {
+            idLote: envelope.idLote ?? overrides?.idLote ?? '1',
+            indSinc: Number(envelope.indSinc ?? overrides?.indSinc ?? 1),
+            NFe: envelope.NFe,
+        };
+    }
+    /**
+     * Converte um XML autorizado (`nfeProc`) ou uma `NFe` solo em uma
+     * estrutura JSON compatível com o gerador de DANFE
+     * (`{ NFe, protNFe? }`), além de retornar a chave de acesso quando
+     * disponível.
+     *
+     * @param xml String XML de entrada.
+     */
+    convertXmlNfeProcToJson(xml) {
+        logger.info('Convertendo nfeProc para JSON', {
+            context: 'XmlParser',
+            method: 'convertXmlNfeProcToJson',
+        });
+        const jsonData = this.parseNfeLikeXml(xml);
+        const nfeProc = this.findInObj(jsonData, 'nfeProc');
+        const NFe = nfeProc ? this.findInObj(nfeProc, 'NFe') : this.findInObj(jsonData, 'NFe');
+        if (!NFe) {
+            throw new Error('XML inválido: não foi possível localizar `NFe` ou `nfeProc`.');
+        }
+        const protNFe = nfeProc ? this.findInObj(nfeProc, 'protNFe') : this.findInObj(jsonData, 'protNFe');
+        const chFromProt = protNFe?.infProt?.chNFe;
+        const idAttr = NFe?.infNFe?.Id ?? '';
+        const chFromId = typeof idAttr === 'string' ? idAttr.replace(/^NFe/, '') : '';
+        const chave = chFromProt || chFromId || '';
+        const data = { NFe };
+        if (protNFe)
+            data.protNFe = protNFe;
+        return { data, chave };
+    }
+    /**
+     * Faz o parse de um XML de NFe/NFCe (envio, retorno ou solo) preservando
+     * atributos e elevando-os para o nível do elemento (ex.: `Id` em `infNFe`,
+     * `versao` em `NFe`, `nItem` em `det`). Necessário para alimentar o
+     * fluxo interno da lib que espera atributos como propriedades comuns.
+     */
+    parseNfeLikeXml(xml) {
+        const jsonAsString = convert__namespace.xml2json(xml, {
+            compact: true,
+            spaces: 2,
+            ignoreAttributes: false,
+            ignoreDeclaration: true,
+            trim: true,
+            ignoreInstruction: true,
+            ignoreComment: true,
+            ignoreCdata: true,
+            ignoreDoctype: true,
+            textFn: this.removeJsonTextAttribute,
+        });
+        const parsed = JSON.parse(jsonAsString);
+        this.liftAttributes(parsed);
+        return parsed;
+    }
+    /**
+     * Eleva, recursivamente, as chaves de `_attributes` para o próprio nível
+     * do elemento e remove o nó `_attributes`. Compatível com a saída de
+     * `xml-js` em modo compacto.
+     */
+    liftAttributes(node) {
+        if (!node || typeof node !== 'object')
+            return;
+        if (Array.isArray(node)) {
+            node.forEach(item => this.liftAttributes(item));
+            return;
+        }
+        if (node._attributes && typeof node._attributes === 'object') {
+            for (const attrKey of Object.keys(node._attributes)) {
+                if (!(attrKey in node)) {
+                    node[attrKey] = node._attributes[attrKey];
+                }
+            }
+            delete node._attributes;
+        }
+        for (const key of Object.keys(node)) {
+            const value = node[key];
+            if (value && typeof value === 'object') {
+                this.liftAttributes(value);
+            }
+        }
+    }
+    /**
+     * Normaliza uma `NFe` parseada de XML para o formato interno da lib:
+     *  - converte `CNPJ`/`CPF`/`idEstrangeiro` em `CNPJCPF` em `emit`,
+     *    `dest`, `transp.transporta` e `NFref.refNFP`.
+     *  - remove atributos elevados que a lib re-aplica via `$` ao montar
+     *    o XML final (`infNFe.versao`, `det.nItem`), evitando duplicidade
+     *    no XML gerado.
+     *
+     * Observação: `infRespTec` mantém o campo `CNPJ` original — a lib não
+     * unifica documento para esse nó.
+     */
+    normalizeNfeForLibFormat(nfeNode) {
+        const infNFe = nfeNode?.infNFe;
+        if (!infNFe || typeof infNFe !== 'object')
+            return;
+        // versao é re-aplicado pela lib via $ ao montar `infNFe`
+        delete infNFe.versao;
+        // O atributo `Id` no XML vem com prefixo "NFe" (ex.: "NFe4126..."),
+        // mas a lib espera apenas a chave de 44 dígitos em `infNFe.Id` —
+        // ela própria re-prefixa com "NFe" ao calcular `chaveAcesso`.
+        if (typeof infNFe.Id === 'string' && /^NFe\d{44}$/.test(infNFe.Id)) {
+            infNFe.Id = infNFe.Id.slice(3);
+        }
+        this.unifyDocFields(infNFe.emit);
+        this.unifyDocFields(infNFe.dest);
+        this.unifyDocFields(infNFe.transp?.transporta);
+        // nItem é re-aplicado pela lib via $ em cada `det` quando é array.
+        // Por isso normalizamos sempre para array (no XML, com 1 item, viraria
+        // objeto único e a lib não re-aplicaria nItem, quebrando a validação XSD).
+        const det = infNFe.det;
+        if (Array.isArray(det)) {
+            det.forEach((d) => { if (d && typeof d === 'object')
+                delete d.nItem; });
+        }
+        else if (det && typeof det === 'object') {
+            delete det.nItem;
+            infNFe.det = [det];
+        }
+        const NFref = infNFe.NFref;
+        if (Array.isArray(NFref)) {
+            NFref.forEach((ref) => this.unifyDocFields(ref?.refNFP));
+        }
+        else if (NFref && typeof NFref === 'object') {
+            this.unifyDocFields(NFref.refNFP);
+        }
+    }
+    /**
+     * Em um nó (ex.: `emit`, `dest`), unifica `CNPJ`/`CPF`/`idEstrangeiro`
+     * em um único campo `CNPJCPF`, removendo as chaves originais. Mantém a
+     * primeira não-vazia encontrada na ordem `CNPJ → CPF → idEstrangeiro`.
+     */
+    unifyDocFields(target) {
+        if (!target || typeof target !== 'object')
+            return;
+        if (target.CNPJCPF)
+            return;
+        const candidate = target.CNPJ || target.CPF || target.idEstrangeiro;
+        if (candidate) {
+            target.CNPJCPF = candidate;
+        }
+        delete target.CNPJ;
+        delete target.CPF;
+        delete target.idEstrangeiro;
+    }
 }
 
 class BaseNFE {
@@ -765,6 +954,7 @@ class GerarConsulta {
             const config = this.environment.getConfig();
             // Capturando o schema path
             const { schemaPath } = this.utility.getSchema(metodo);
+            logger.info(xmlConsulta);
             // Valida Schema apenas se o schema path estiver definido
             if (schemaPath) {
                 if (config.lib?.useForSchemaValidation !== 'validateSchemaJsBased') {
@@ -1015,6 +1205,7 @@ const getSchema = (metodo) => {
         RecepcaoEvento: `${pathSchemas}/envEvento_v1.00.xsd`,
         NFeDistribuicaoDFe: `${pathSchemas}/distDFeInt_v1.01.xsd`,
         NFEAutorizacao: `${pathSchemas}/enviNFe_v4.00.xsd`,
+        NFeAutorizacao: `${pathSchemas}/enviNFe_v4.00.xsd`,
         NFEInutilizacao: `${pathSchemas}/inutNFe_v4.00.xsd`,
         NFERetAutorizacao: `${pathSchemas}/consReciNFe_v4.00.xsd`,
         CTeDistribuicaoDFe: `${pathSchemas}/cte/distDFeInt_v1.00.xsd`,
@@ -3678,6 +3869,254 @@ 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/>.
+ */
+/** Remove o prefixo `{namespace}` deixando apenas o nome local do elemento. */
+function stripNamespace(name) {
+    return name.replace(/^\{[^}]*\}/, '');
+}
+/**
+ * Interpreta uma mensagem de erro do libxmljs2 / xsd-schema-validator e retorna
+ * um `SchemaValidationIssue` com versão humanizada + metadados estruturados.
+ */
+function humanizeIssue(raw, line, column) {
+    const issue = { raw, humanized: raw, line, column };
+    // 1) Elemento com filhos ausentes
+    //    Element '{ns}Nome': Missing child element(s). Expected is one of ( {ns}a, {ns}b ).
+    let m = raw.match(/Element\s+'([^']+)':\s*Missing child element\(s\)\.\s*Expected is one of\s*\(\s*([^)]+)\s*\)\.?/i);
+    if (m) {
+        const element = stripNamespace(m[1]);
+        const expected = m[2].split(',').map((s) => stripNamespace(s.trim())).filter(Boolean);
+        issue.element = element;
+        issue.expected = expected;
+        issue.humanized = `Elemento <${element}> está incompleto. Filho ausente, esperado um de: ${expected.join(', ')}.`;
+        return issue;
+    }
+    // 2) Elemento não esperado
+    //    Element '{ns}Nome': This element is not expected. Expected is one of ( {ns}a, {ns}b ).
+    m = raw.match(/Element\s+'([^']+)':\s*This element is not expected\.\s*(?:Expected is one of\s*\(\s*([^)]+)\s*\)\.?)?/i);
+    if (m) {
+        const element = stripNamespace(m[1]);
+        issue.element = element;
+        if (m[2]) {
+            issue.expected = m[2].split(',').map((s) => stripNamespace(s.trim())).filter(Boolean);
+            issue.humanized = `Elemento <${element}> inesperado nesta posição. Esperado um de: ${issue.expected.join(', ')}.`;
+        }
+        else {
+            issue.humanized = `Elemento <${element}> inesperado nesta posição.`;
+        }
+        return issue;
+    }
+    // 3) Atributo inválido / faltando
+    //    Element '{ns}Nome', attribute 'attr': ...
+    m = raw.match(/Element\s+'([^']+)',\s*attribute\s+'([^']+)':\s*(.+?)\.?$/i);
+    if (m) {
+        const element = stripNamespace(m[1]);
+        const attribute = m[2];
+        const desc = m[3];
+        issue.element = element;
+        issue.attribute = attribute;
+        issue.humanized = `Elemento <${element}> — atributo "${attribute}": ${desc}.`;
+        return issue;
+    }
+    // 4) Valor inválido para tipo
+    //    Element '{ns}Nome': [facet 'pattern'] The value '...' is not accepted by the pattern '...'.
+    //    Element '{ns}Nome': '...' is not a valid value of the atomic type 'TString'.
+    m = raw.match(/Element\s+'([^']+)':\s*(?:\[facet[^\]]*\]\s*)?(.+?)\.?$/i);
+    if (m) {
+        const element = stripNamespace(m[1]);
+        issue.element = element;
+        issue.humanized = `Elemento <${element}>: ${m[2]}.`;
+        return issue;
+    }
+    // 5) Sem padrão reconhecido — devolve raw como humanizado
+    return issue;
+}
+/** Cria um issue "interno" quando o erro não veio do schema (ex.: XML mal formado). */
+function internalIssue(raw) {
+    return { raw, humanized: raw };
+}
+/**
+ * Monta o relatório textual estilo SEFAZ-RS pronto para `console.log`.
+ */
+function buildReport(metodo, schemaFile, errors) {
+    const linhas = [];
+    linhas.push('=== Resultado da Validação do Schema ===');
+    linhas.push(`Tipo de Mensagem: ${metodo}`);
+    linhas.push(`Schema XML:       ${schemaFile}`);
+    if (errors.length === 0) {
+        linhas.push('Parser XML:       Nenhum erro encontrado');
+        linhas.push('Schema XML:       Nenhum erro encontrado');
+        linhas.push('Status:           XML válido.');
+    }
+    else {
+        linhas.push(`Status:           ${errors.length} erro(s) de validação`);
+        linhas.push('');
+        errors.forEach((err, idx) => {
+            const pos = err.line ? ` (linha ${err.line}${err.column ? `, col ${err.column}` : ''})` : '';
+            linhas.push(`  ${idx + 1}. ${err.humanized}${pos}`);
+        });
+    }
+    linhas.push('=========================================');
+    return linhas.join('\n');
+}
+/** Converte a lista de erros em linhas para `console.table`. */
+function buildTableRows(errors) {
+    if (errors.length === 0) {
+        return [{ '#': 1, Linha: '', Elemento: '-', Mensagem: 'XML válido.' }];
+    }
+    return errors.map((err, idx) => ({
+        '#': idx + 1,
+        Linha: err.line ?? '',
+        Elemento: err.element ?? '-',
+        Mensagem: err.humanized,
+    }));
+}
+function schemaFileName(schemaPath) {
+    if (!schemaPath)
+        return '-';
+    const parts = schemaPath.split(/[\\/]/);
+    return parts[parts.length - 1] || schemaPath;
+}
+function makeResult(success, metodo, schemaPath, errors) {
+    const schema = schemaFileName(schemaPath);
+    const report = buildReport(metodo, schema, errors);
+    const message = success
+        ? 'XML válido.'
+        : errors[0]?.humanized ?? 'Erro de validação não identificado.';
+    return {
+        success,
+        message,
+        errors,
+        report,
+        tableRows: buildTableRows(errors),
+        metodo,
+        schema,
+    };
+}
+function runJsBased(xml, metodo) {
+    return new Promise(async (resolve, reject) => {
+        const { basePath, schemaPath } = getSchema(metodo);
+        if (!schemaPath) {
+            reject(makeResult(false, metodo, '', [internalIssue(`Schema XSD não encontrado para o método '${metodo}'. Verifique se o nome do método está correto.`)]));
+            return;
+        }
+        try {
+            const completeXSD = await xsdAssembler.assemble(schemaPath);
+            const xmlDoc = libxmljs.parseXml(xml);
+            const xsdDoc = libxmljs.parseXml(completeXSD, { baseUrl: `${basePath}/` });
+            const isValid = xmlDoc.validate(xsdDoc);
+            if (isValid) {
+                resolve(makeResult(true, metodo, schemaPath, []));
+                return;
+            }
+            const errors = (xmlDoc.validationErrors || []).map((e) => humanizeIssue(String(e.message ?? e).trim(), e.line, e.column));
+            reject(makeResult(false, metodo, schemaPath, errors.length ? errors : [internalIssue('XML inválido (sem detalhes do validador).')]));
+        }
+        catch (error) {
+            reject(makeResult(false, metodo, schemaPath, [internalIssue(String(error?.message ?? error))]));
+        }
+    });
+}
+function runJavaBased(xml, metodo) {
+    return new Promise((resolve, reject) => {
+        const { schemaPath } = getSchema(metodo);
+        if (!schemaPath) {
+            reject(makeResult(false, metodo, '', [internalIssue(`Schema XSD não encontrado para o método '${metodo}'. Verifique se o nome do método está correto.`)]));
+            return;
+        }
+        try {
+            xsdValidator.validateXML(xml, schemaPath, (err, validationResult) => {
+                if (err) {
+                    reject(makeResult(false, metodo, schemaPath, [humanizeIssue(String(err.message ?? err))]));
+                    return;
+                }
+                if (!validationResult?.valid) {
+                    const msgs = validationResult?.messages ?? [];
+                    const errors = msgs.length
+                        ? msgs.map((m) => humanizeIssue(String(m)))
+                        : [internalIssue('XML inválido (sem detalhes do validador).')];
+                    reject(makeResult(false, metodo, schemaPath, errors));
+                    return;
+                }
+                resolve(makeResult(true, metodo, schemaPath, []));
+            });
+        }
+        catch (error) {
+            reject(makeResult(false, metodo, schemaPath, [internalIssue(String(error?.message ?? error))]));
+        }
+    });
+}
+/**
+ * Valida um XML contra o schema XSD correspondente ao método fiscal informado.
+ *
+ * ### Seleção do validador (ordem de prioridade)
+ * 1. `options.validator` — escolha explícita do caller.
+ * 2. `options.environment.getConfig().lib?.useForSchemaValidation` — valor definido
+ *    na inicialização da lib.
+ * 3. `'validateSchemaJsBased'` — padrão (sem JDK).
+ *
+ * @param xml     - String XML a ser validada.
+ * @param metodo  - Nome do método/operação fiscal (ex.: `'NFeAutorizacao'`).
+ * @param options - Opções opcionais: `validator` e/ou `environment`.
+ *
+ * @example
+ * // Sem opções: usa validateSchemaJsBased
+ * await NFE_SchemaValidate(xml, 'NFeAutorizacao');
+ *
+ * @example
+ * // Passando o environment inicializado pela lib (lê useForSchemaValidation do config)
+ * await NFE_SchemaValidate(xml, 'NFeAutorizacao', { environment });
+ *
+ * @example
+ * // Forçando um validador específico
+ * await NFE_SchemaValidate(xml, 'NFeAutorizacao', { validator: 'validateSchemaJavaBased' });
+ */
+function NFE_SchemaValidate(xml, metodo, options) {
+    let chosen = 'validateSchemaJsBased';
+    if (options?.validator) {
+        chosen = options.validator;
+    }
+    else if (options?.environment) {
+        const fromConfig = options.environment.getConfig()?.lib?.useForSchemaValidation;
+        if (fromConfig)
+            chosen = fromConfig;
+    }
+    const xmlNormalizado = wrapEnviNFeIfNeeded(xml, metodo);
+    return chosen === 'validateSchemaJavaBased'
+        ? runJavaBased(xmlNormalizado, metodo)
+        : runJsBased(xmlNormalizado, metodo);
+}
+/**
+ * Para os métodos de autorização de NF-e, o schema XSD (`enviNFe_v4.00.xsd`)
+ * exige que o elemento raiz seja `<enviNFe>`. Quando o caller passa apenas a
+ * árvore `<NFe>`, envelopamos automaticamente em `<enviNFe>` com `idLote=1` e
+ * `indSinc=1` para que a validação funcione.
+ */
+function wrapEnviNFeIfNeeded(xml, metodo) {
+    if (metodo !== 'NFEAutorizacao' && metodo !== 'NFeAutorizacao')
+        return xml;
+    const semDecl = xml.replace(/^\s*<\?xml[^?]*\?>\s*/, '').trimStart();
+    if (/^<NFe[\s>]/.test(semDecl)) {
+        return `<enviNFe versao="4.00" xmlns="http://www.portalfiscal.inf.br/nfe"><idLote>1</idLote><indSinc>1</indSinc>${semDecl}</enviNFe>`;
+    }
+    return xml;
+}
+
 /*
  * This file is part of NFeWizard-io.
  *
@@ -3863,12 +4302,35 @@ class LoadCertificate {
         this.certificate = '';
         this.cert_key = '';
     }
-    loadCertificateWithPEM() {
+    /**
+     * Resolve o conteúdo binário do PFX a partir do `pathCertificado` informado em
+     * config. Aceita `string` (caminho), `Buffer` ou `NodeJS.ReadableStream`.
+     */
+    async resolvePfxBuffer() {
+        const input = this.config.dfe.pathCertificado;
+        if (typeof input === 'string') {
+            return fs.readFileSync(input);
+        }
+        if (Buffer.isBuffer(input)) {
+            return input;
+        }
+        if (input && typeof input.pipe === 'function') {
+            const stream = input;
+            return await new Promise((resolve, reject) => {
+                const chunks = [];
+                stream.on('data', (chunk) => {
+                    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+                });
+                stream.on('end', () => resolve(Buffer.concat(chunks)));
+                stream.on('error', (err) => reject(err));
+            });
+        }
+        throw new Error('pathCertificado deve ser uma string (path), Buffer ou Stream legível.');
+    }
+    loadCertificateWithPEM(pfxFile) {
         return new Promise((resolve, reject) => {
             try {
-                const pfxPath = this.config.dfe.pathCertificado;
                 const pfxPassword = this.config.dfe.senhaCertificado;
-                const pfxFile = fs.readFileSync(pfxPath);
                 const certsDir = path.resolve(baseDir, dir);
                 // Read CA certificates if directory exists and has files
                 let caCerts = [];
@@ -3927,13 +4389,10 @@ class LoadCertificate {
             }
         });
     }
-    loadCertificateWithNodeForge() {
+    loadCertificateWithNodeForge(pfxFile) {
         return new Promise((resolve, reject) => {
             try {
-                const pfxPath = this.config.dfe.pathCertificado;
                 const pfxPassword = this.config.dfe.senhaCertificado;
-                // Lê o arquivo PFX
-                const pfxFile = fs.readFileSync(pfxPath);
                 // Decodifica o arquivo PFX (PKCS#12)
                 const p12Asn1 = forge.asn1.fromDer(pfxFile.toString('binary'));
                 const p12 = forge.pkcs12.pkcs12FromAsn1(p12Asn1, pfxPassword);
@@ -4005,15 +4464,16 @@ class LoadCertificate {
         logger.info('Validando certificado', {
             context: 'LoadCertificate',
         });
+        const pfxFile = await this.resolvePfxBuffer();
         if (this.config.lib?.useOpenSSL || this.config.lib?.useOpenSSL === undefined) {
-            const { agent } = await this.loadCertificateWithPEM();
+            const { agent } = await this.loadCertificateWithPEM(pfxFile);
             return {
                 certificate: this.certificate,
                 cert_key: this.cert_key,
                 agent
             };
         }
-        const { agent } = await this.loadCertificateWithNodeForge();
+        const { agent } = await this.loadCertificateWithNodeForge(pfxFile);
         return {
             certificate: this.certificate,
             cert_key: this.cert_key,
@@ -4105,6 +4565,7 @@ exports.GerarConsulta = GerarConsulta;
 exports.HttpClientBuilder = HttpClientBuilder;
 exports.JsonArrayTransport = JsonArrayTransport;
 exports.LoadCertificate = LoadCertificate;
+exports.NFE_SchemaValidate = NFE_SchemaValidate;
 exports.SaveFiles = SaveFiles;
 exports.Utility = Utility;
 exports.ValidaCPFCNPJ = ValidaCPFCNPJ;