ghinfe 0.6.0

package/src/nfce/services/NFCeService.js

@@ -0,0 +1,188 @@
+import { NFCeXmlService } from './NFCeXmlService.js';
+import { NFeSignService } from '../../nfe/services/NFeSignService.js';
+import { NFeSoapService } from '../../nfe/services/NFeSoapService.js';
+import { GhinfeError } from '../../errors/GhinfeError.js';
+import { gerarChaveAcesso, validarChaveAcesso } from '../../utils/chave.utils.js';
+import { SefazEndpointResolver } from '../../sefaz/SefazEndpointResolver.js';
+import {
+  extrairDigestValor,
+  gerarUrlQrCodeV3,
+  obterUrlChave,
+  inserirInfNFeSupl,
+} from '../utils/qrcode.utils.js';
+
+/**
+ * Orquestrador da NFC-e (modelo 65).
+ */
+export class NFCeService {
+  /**
+   * @param {{
+   *   mock?: boolean,
+   *   uf?: string,
+   *   ambiente?: number,
+   *   sefazEndpoint?: string,
+   *   mockScenario?: string,
+   *   validarXsd?: boolean,
+   * }} [options]
+   */
+  constructor(options = {}) {
+    this.options = options;
+    this.xmlService = new NFCeXmlService({ validarXsd: options.validarXsd });
+    this.signService = new NFeSignService();
+
+    let endpoint = options.sefazEndpoint;
+    if (!endpoint && options.uf && !options.mock) {
+      endpoint = SefazEndpointResolver.paraNFCe(options.uf, options.ambiente ?? 2).endpoint;
+    }
+
+    this.soapService = new NFeSoapService({
+      mock: options.mock ?? true,
+      endpoint,
+      mockScenario: options.mockScenario,
+    });
+  }
+
+  /** @param {string} uf @param {number} [ambiente] */
+  configurarUf(uf, ambiente = 2) {
+    const urls = SefazEndpointResolver.paraNFCe(uf, ambiente);
+    this.soapService.endpoint = urls.endpoint;
+    this.soapService.mock = false;
+    return urls;
+  }
+
+  /** @param {import('../types/NFCeDocument.js').NFCeDocumento} documento */
+  resolverDocumento(documento) {
+    if (documento.chaveAcesso) {
+      if (!validarChaveAcesso(documento.chaveAcesso)) {
+        throw new GhinfeError('chaveAcesso com dígito verificador inválido', 'CHAVE_DV_INVALIDO');
+      }
+      return documento;
+    }
+
+    const chaveAcesso = gerarChaveAcesso({
+      uf: documento.ide.uf,
+      cnpj: documento.emitente.cnpj,
+      modelo: '65',
+      serie: documento.ide.serie ?? 1,
+      numero: documento.ide.numero,
+    });
+
+    return { ...documento, chaveAcesso };
+  }
+
+  /** @param {import('../types/NFCeDocument.js').NFCeDocumento} documento */
+  #calcularTotais(documento) {
+    const valorProdutos = documento.itens.reduce((s, i) => s + i.valorTotal, 0);
+    const valorIcms = documento.itens.reduce((s, i) => s + (i.valorIcms ?? 0), 0);
+    const valorDesc = documento.itens.reduce((s, i) => s + (i.valorDesconto ?? 0), 0);
+    return { valorNF: valorProdutos - valorDesc, valorIcms };
+  }
+
+  /**
+   * Gera XML base (infNFe) sem QR Code — QR é adicionado após assinatura.
+   * @param {import('../types/NFCeDocument.js').NFCeDocumento} documento
+   * @param {{ validarXsd?: boolean }} [options]
+   */
+  gerarXml(documento, options = {}) {
+    const doc = this.resolverDocumento(documento);
+    return this.xmlService.gerarXml(doc, { ...options, validarXsd: false });
+  }
+
+  /**
+   * Adiciona infNFeSupl com QR Code v3 ao XML já assinado.
+   * @param {string} xmlAssinado
+   * @param {import('../types/NFCeDocument.js').NFCeDocumento} documento
+   */
+  adicionarQrCode(xmlAssinado, documento) {
+    const doc = this.resolverDocumento(documento);
+    const { valorNF, valorIcms } = this.#calcularTotais(doc);
+    const digVal = extrairDigestValor(xmlAssinado);
+    const cDest = (doc.destinatario?.cnpj ?? doc.destinatario?.cpf ?? '').replace(/\D/g, '');
+
+    const qrCode = gerarUrlQrCodeV3({
+      chaveAcesso: doc.chaveAcesso,
+      uf: doc.ide.uf,
+      ambiente: doc.ambiente ?? 2,
+      cDest,
+      valorNF,
+      valorICMS: valorIcms,
+      digVal,
+      idCSC: doc.csc.idCSC,
+      csc: doc.csc.codigo,
+    });
+
+    const urlChave = obterUrlChave(doc.ide.uf, doc.ambiente ?? 2);
+    const xmlCompleto = inserirInfNFeSupl(xmlAssinado, qrCode, urlChave);
+
+    return { xmlCompleto, qrCode, urlChave };
+  }
+
+  /**
+   * @param {import('../types/NFCeDocument.js').NFCeDocumento} documento
+   * @param {{ pfx: Buffer|string, senha: string }} certificado
+   * @param {{ validarXsd?: boolean }} [options]
+   */
+  gerarXmlAssinado(documento, certificado, options = {}) {
+    const doc = this.resolverDocumento(documento);
+    const xml = this.xmlService.gerarXml(doc, { validarXsd: false });
+    const xmlAssinado = this.signService.assinar(xml, certificado.pfx, certificado.senha);
+    const { xmlCompleto, qrCode } = this.adicionarQrCode(xmlAssinado, doc);
+
+    if (options.validarXsd) {
+      this.xmlService.validarXml(xmlCompleto);
+    }
+
+    return { xml: xmlCompleto, qrCode };
+  }
+
+  /**
+   * @param {import('../types/NFCeDocument.js').NFCeDocumento} documento
+   * @param {{ pfx: Buffer|string, senha: string }} certificado
+   */
+  async emitir(documento, certificado) {
+    const doc = this.resolverDocumento(documento);
+
+    if (!this.soapService.mock && this.options.uf === undefined && !this.options.sefazEndpoint) {
+      this.configurarUf(doc.ide.uf, doc.ambiente ?? 2);
+    }
+
+    const { xml, qrCode } = this.gerarXmlAssinado(doc, certificado);
+    const retorno = await this.soapService.autorizar(xml, doc.chaveAcesso);
+
+    return {
+      chaveAcesso: doc.chaveAcesso,
+      qrCode,
+      xmlGerado: this.gerarXml(doc),
+      xmlAssinado: xml,
+      retorno,
+    };
+  }
+
+  /** @param {string} xml */
+  validarXsd(xml) {
+    return this.xmlService.validarXml(xml);
+  }
+
+  async enviar(xmlAssinado, chaveAcesso) {
+    return this.soapService.autorizar(xmlAssinado, chaveAcesso);
+  }
+
+  /** @param {Awaited<ReturnType<NFCeService['emitir']>>} resultado */
+  toPersistencePayload(resultado) {
+    if (!resultado.retorno.autorizado) {
+      throw new GhinfeError('NFC-e não autorizada', 'NFCE_NOT_AUTHORIZED', resultado.retorno);
+    }
+
+    return {
+      chave_acesso: resultado.chaveAcesso,
+      modelo: '65',
+      xml_nfce: resultado.xmlAssinado,
+      xml_protocolo: resultado.retorno.xmlProtocolo,
+      protocolo: resultado.retorno.protocolo,
+      qrcode_url: resultado.qrCode,
+      status: resultado.retorno.cStat,
+      motivo: resultado.retorno.xMotivo,
+      autorizado_em: new Date(),
+    };
+  }
+}

package/src/nfce/services/NFCeXmlService.js

@@ -0,0 +1,38 @@
+import { NFCeXmlBuilder } from '../builders/NFCeXmlBuilder.js';
+import { NFeXsdService } from '../../nfe/services/NFeXsdService.js';
+
+/**
+ * Serviço de geração e validação XSD da NFC-e.
+ */
+export class NFCeXmlService {
+  /**
+   * @param {{ validarXsd?: boolean }} [options]
+   */
+  constructor(options = {}) {
+    this.builder = new NFCeXmlBuilder();
+    this.xsdService = new NFeXsdService();
+    this.validarXsd = options.validarXsd ?? false;
+  }
+
+  /**
+   * @param {import('../types/NFCeDocument.js').NFCeDocumento} documento
+   * @param {{ validarXsd?: boolean }} [options]
+   */
+  gerarXml(documento, options = {}) {
+    const xml = this.builder.build(documento);
+    const deveValidar = options.validarXsd ?? this.validarXsd;
+
+    if (deveValidar) {
+      this.xsdService.validarNFCe(xml, { preAssinatura: true });
+    }
+
+    return xml;
+  }
+
+  /**
+   * @param {string} xml
+   */
+  validarXml(xml) {
+    return this.xsdService.validarNFCe(xml);
+  }
+}

package/src/nfce/types/NFCeDocument.js

@@ -0,0 +1,42 @@
+/**
+ * @typedef {import('../../nfe/types/NFeDocument.js').NFeEndereco} NFCeEndereco
+ * @typedef {import('../../nfe/types/NFeDocument.js').NFeEmitente} NFCeEmitente
+ * @typedef {import('../../nfe/types/NFeDocument.js').NFeItem} NFCeItem
+ * @typedef {import('../../nfe/types/NFeDocument.js').NFePagamento} NFCePagamento
+ */
+
+/**
+ * @typedef {Object} NFCeDestinatario
+ * @property {string} [cpf]
+ * @property {string} [cnpj]
+ * @property {string} [razaoSocial]
+ * @property {NFCeEndereco} [endereco]
+ */
+
+/**
+ * @typedef {Object} NFCeCsc
+ * @property {string} idCSC Identificador do CSC (ex "000001")
+ * @property {string} codigo Código CSC fornecido pela SEFAZ
+ */
+
+/**
+ * @typedef {Object} NFCeDocumento
+ * @property {string} [chaveAcesso]
+ * @property {number} [ambiente] 1=Produção, 2=Homologação
+ * @property {Object} ide
+ * @property {string} ide.uf
+ * @property {string} ide.codigoMunicipio
+ * @property {number} [ide.serie]
+ * @property {number} ide.numero
+ * @property {string} [ide.naturezaOperacao]
+ * @property {number} [ide.presenca] 1=Presencial, 4=Entrega domicílio
+ * @property {NFCeEmitente} emitente
+ * @property {NFCeDestinatario} [destinatario]
+ * @property {NFCeItem[]} itens
+ * @property {NFCePagamento[]} [pagamentos]
+ * @property {NFCeCsc} csc Dados do CSC para QR Code
+ * @property {string} [informacoesComplementares]
+ * @property {string} [informacoesFisco]
+ */
+
+export {};

package/src/nfce/utils/qrcode.utils.js

@@ -0,0 +1,92 @@
+import crypto from 'crypto';
+import { NFCE_QRCODE_URLS, NFCE_URL_CHAVE } from '../constants/qrcode.js';
+import { GhinfeError } from '../../errors/GhinfeError.js';
+
+/**
+ * Extrai DigestValue da assinatura XML para compor QR Code v3.
+ * @param {string} xmlAssinado
+ */
+export function extrairDigestValor(xmlAssinado) {
+  const match = xmlAssinado.match(/<DigestValue>([^<]+)<\/DigestValue>/);
+  return match?.[1] ?? '';
+}
+
+/**
+ * Gera hash QR Code NFC-e versão 3.
+ * SHA1(chave + versao + tpAmb + cDest + vNF + vICMS + digVal + idCSC + CSC)
+ */
+export function gerarHashQrCodeV3(chaveAcesso, ambiente, cDest, vNF, vICMS, digVal, idCSC, csc) {
+  const vNFStr = Number(vNF).toFixed(2);
+  const vICMSStr = Number(vICMS).toFixed(2);
+  const id = idCSC.padStart(6, '0');
+  const input = `${chaveAcesso}3${ambiente}${cDest}${vNFStr}${vICMSStr}${digVal}${id}${csc}`;
+  return crypto.createHash('sha1').update(input).digest('hex').toUpperCase();
+}
+
+/**
+ * Monta URL do QR Code NFC-e versão 3 (layout exigido pelo XSD PL_009_V4).
+ * @param {{
+ *   chaveAcesso: string,
+ *   uf: string,
+ *   ambiente?: number,
+ *   cDest?: string,
+ *   valorNF: number,
+ *   valorICMS?: number,
+ *   digVal: string,
+ *   idCSC: string,
+ *   csc: string,
+ * }} params
+ */
+export function gerarUrlQrCodeV3(params) {
+  const ambiente = params.ambiente ?? 2;
+  const uf = params.uf.toUpperCase();
+  const baseUrl = NFCE_QRCODE_URLS[uf]?.[ambiente];
+
+  if (!baseUrl) {
+    throw new GhinfeError(
+      `URL de QR Code NFC-e não configurada para UF ${uf} ambiente ${ambiente}`,
+      'NFCE_QRCODE_URL_MISSING'
+    );
+  }
+
+  const cDest = (params.cDest ?? '').replace(/\D/g, '');
+  const vNFStr = Number(params.valorNF).toFixed(2);
+  const vICMSStr = Number(params.valorICMS ?? 0).toFixed(2);
+  const idCSC = params.idCSC.padStart(6, '0');
+  const hash = gerarHashQrCodeV3(
+    params.chaveAcesso,
+    ambiente,
+    cDest,
+    params.valorNF,
+    params.valorICMS ?? 0,
+    params.digVal,
+    idCSC,
+    params.csc
+  );
+
+  const p = `${params.chaveAcesso}|3|${ambiente}|${cDest}|${vNFStr}|${vICMSStr}|${params.digVal}|${idCSC}|${hash}`;
+  return `${baseUrl}?p=${p}`;
+}
+
+/**
+ * @param {string} uf
+ * @param {number} [ambiente]
+ */
+export function obterUrlChave(uf, ambiente = 2) {
+  const url = NFCE_URL_CHAVE[uf.toUpperCase()]?.[ambiente];
+  if (!url) {
+    return NFCE_QRCODE_URLS[uf.toUpperCase()]?.[ambiente] ?? 'https://www.nfce.fazenda.sp.gov.br/consulta';
+  }
+  return url;
+}
+
+/**
+ * Insere infNFeSupl no XML assinado da NFC-e.
+ * @param {string} xmlAssinado
+ * @param {string} qrCodeUrl
+ * @param {string} urlChave
+ */
+export function inserirInfNFeSupl(xmlAssinado, qrCodeUrl, urlChave) {
+  const supl = `<infNFeSupl><qrCode><![CDATA[${qrCodeUrl}]]></qrCode><urlChave>${urlChave}</urlChave></infNFeSupl>`;
+  return xmlAssinado.replace('</NFe>', `${supl}</NFe>`);
+}

package/src/nfe/builders/NFeEventoXmlBuilder.js

@@ -0,0 +1,110 @@
+import { create } from 'xmlbuilder2';
+import { UF_IBGE } from '../../constants/sefaz.js';
+import { NFE_EVENTOS, CCE_COND_USO } from '../types/NFeEvento.js';
+import { formatSefazDateTime } from '../../utils/date.utils.js';
+import { GhinfeError } from '../../errors/GhinfeError.js';
+
+const VERSAO_EVENTO = '1.00';
+
+/**
+ * Monta XML de eventos NF-e (cancelamento, CC-e, etc.).
+ */
+export class NFeEventoXmlBuilder {
+  /**
+   * @param {import('../types/NFeEvento.js').NFeCancelamento} dados
+   * @returns {string}
+   */
+  buildCancelamento(dados) {
+    this.#validarBase(dados);
+    if (!dados.protocolo) {
+      throw new GhinfeError('protocolo é obrigatório para cancelamento', 'CANCEL_PROTOCOLO_REQUIRED');
+    }
+    if (!dados.justificativa || dados.justificativa.trim().length < 15) {
+      throw new GhinfeError(
+        'justificativa deve ter no mínimo 15 caracteres',
+        'CANCEL_JUSTIFICATIVA_MIN'
+      );
+    }
+
+    return this.#buildEvento(dados, NFE_EVENTOS.CANCELAMENTO, (det) => {
+      det.ele('descEvento').txt('Cancelamento').up();
+      det.ele('nProt').txt(dados.protocolo).up();
+      det.ele('xJust').txt(dados.justificativa.trim()).up();
+    });
+  }
+
+  /**
+   * @param {import('../types/NFeEvento.js').NFeCartaCorrecao} dados
+   * @returns {string}
+   */
+  buildCartaCorrecao(dados) {
+    this.#validarBase(dados);
+    if (!dados.correcao || dados.correcao.trim().length < 15) {
+      throw new GhinfeError(
+        'correcao deve ter no mínimo 15 caracteres',
+        'CCE_TEXTO_MIN'
+      );
+    }
+    if (dados.correcao.length > 1000) {
+      throw new GhinfeError('correcao não pode exceder 1000 caracteres', 'CCE_TEXTO_MAX');
+    }
+
+    return this.#buildEvento(dados, NFE_EVENTOS.CARTA_CORRECAO, (det) => {
+      det.ele('descEvento').txt('Carta de Correcao').up();
+      det.ele('xCorrecao').txt(dados.correcao.trim()).up();
+      det.ele('xCondUso').txt(CCE_COND_USO).up();
+    });
+  }
+
+  /**
+   * @param {import('../types/NFeEvento.js').NFeEventoBase} dados
+   * @param {string} tpEvento
+   * @param {(det: import('xmlbuilder2').XMLBuilder) => void} buildDetEvento
+   */
+  #buildEvento(dados, tpEvento, buildDetEvento) {
+    const sequencia = dados.sequencia ?? 1;
+    const idLote = dados.idLote ?? '1';
+    const cOrgao = UF_IBGE[dados.uf.toUpperCase()] ?? '35';
+    const dhEvento = formatSefazDateTime();
+    const idInfEvento = `ID${tpEvento}${dados.chaveAcesso}${String(sequencia).padStart(2, '0')}`;
+
+    const root = create({ version: '1.0', encoding: 'UTF-8' })
+      .ele('envEvento', { xmlns: 'http://www.portalfiscal.inf.br/nfe', versao: VERSAO_EVENTO })
+      .ele('idLote').txt(idLote).up();
+
+    const evento = root.ele('evento', { versao: VERSAO_EVENTO });
+    const infEvento = evento.ele('infEvento', { Id: idInfEvento });
+
+    infEvento
+      .ele('cOrgao').txt(cOrgao).up()
+      .ele('tpAmb').txt(String(dados.ambiente ?? 2)).up()
+      .ele('CNPJ').txt(dados.cnpj.replace(/\D/g, '')).up()
+      .ele('chNFe').txt(dados.chaveAcesso).up()
+      .ele('dhEvento').txt(dhEvento).up()
+      .ele('tpEvento').txt(tpEvento).up()
+      .ele('nSeqEvento').txt(String(sequencia)).up()
+      .ele('verEvento').txt(VERSAO_EVENTO).up();
+
+    const detEvento = infEvento.ele('detEvento', { versao: VERSAO_EVENTO });
+    buildDetEvento(detEvento);
+    detEvento.up();
+    infEvento.up();
+    evento.up();
+
+    return root.end({ prettyPrint: false, headless: false });
+  }
+
+  /** @param {import('../types/NFeEvento.js').NFeEventoBase} dados */
+  #validarBase(dados) {
+    const chave = dados.chaveAcesso?.replace(/\D/g, '');
+    if (!chave || chave.length !== 44) {
+      throw new GhinfeError('chaveAcesso deve conter 44 dígitos', 'INVALID_CHAVE');
+    }
+    if (!dados.cnpj) {
+      throw new GhinfeError('cnpj do autor do evento é obrigatório', 'INVALID_CNPJ');
+    }
+    if (!dados.uf) {
+      throw new GhinfeError('uf é obrigatória', 'INVALID_UF');
+    }
+  }
+}

package/src/nfe/builders/NFeXmlBuilder.js

@@ -0,0 +1,215 @@
+import { create } from 'xmlbuilder2';
+import { NFE_VERSAO } from '../../constants/sefaz.js';
+import { formatSefazDateTime } from '../../utils/date.utils.js';
+import { GhinfeError } from '../../errors/GhinfeError.js';
+import {
+  reformaHabilitada,
+  normalizarItensReforma,
+  somarTotaisReforma,
+  appendTotaisIBSCBS,
+  appendIBSCBS,
+} from '../../reforma/ibscbs.js';
+
+/**
+ * Monta o XML da NF-e (layout 4.00).
+ * Com item.reforma ou reformaTributaria, injeta grupos IBS/CBS (PL_010 experimental).
+ * Atenção: validar XSD PL_009 com reforma ativa pode falhar — use validarXsd só sem reforma,
+ * ou aguarde schemas PL_010.
+ */
+export class NFeXmlBuilder {
+  /**
+   * @param {import('../types/NFeDocument.js').NFeDocument} documento
+   * @returns {string}
+   */
+  build(documento) {
+    this.#validar(documento);
+
+    const comReforma = reformaHabilitada(documento);
+    const itens = comReforma ? normalizarItensReforma(documento.itens, true) : documento.itens;
+
+    const dhEmi = formatSefazDateTime();
+    const dhSaiEnt = formatSefazDateTime();
+    const idInfNFe = `NFe${documento.chaveAcesso}`;
+
+    const totalProdutos = itens.reduce((s, i) => s + i.valorTotal, 0);
+    const valorFrete = documento.frete?.valor ?? 0;
+    const valorIcms = itens.reduce((s, i) => s + (i.valorIcms ?? 0), 0);
+    const valorNf = totalProdutos + valorFrete;
+    const totaisReforma = comReforma ? somarTotaisReforma(itens) : null;
+
+    const root = create({ version: '1.0', encoding: 'UTF-8' })
+      .ele('NFe', { xmlns: 'http://www.portalfiscal.inf.br/nfe' })
+      .ele('infNFe', { versao: NFE_VERSAO, Id: idInfNFe });
+
+    const inf = root;
+
+    inf
+      .ele('ide')
+      .ele('cUF').txt(this.#codigoUf(documento.ide.uf)).up()
+      .ele('cNF').txt(documento.chaveAcesso.substring(35, 43)).up()
+      .ele('natOp').txt(documento.ide.naturezaOperacao ?? 'VENDA').up()
+      .ele('mod').txt('55').up()
+      .ele('serie').txt(String(documento.ide.serie ?? 1)).up()
+      .ele('nNF').txt(String(documento.ide.numero)).up()
+      .ele('dhEmi').txt(dhEmi).up()
+      .ele('dhSaiEnt').txt(dhSaiEnt).up()
+      .ele('tpNF').txt('1').up()
+      .ele('idDest').txt('1').up()
+      .ele('cMunFG').txt(documento.ide.codigoMunicipio).up()
+      .ele('tpImp').txt('1').up()
+      .ele('tpEmis').txt(String(documento.ide.tipoEmissao ?? 1)).up()
+      .ele('cDV').txt(documento.chaveAcesso.slice(-1)).up()
+      .ele('tpAmb').txt(String(documento.ambiente ?? 2)).up()
+      .ele('finNFe').txt(String(documento.ide.finalidade ?? 1)).up()
+      .ele('indFinal').txt(String(documento.ide.consumidorFinal ?? 1)).up()
+      .ele('indPres').txt(String(documento.ide.presenca ?? 1)).up()
+      .ele('procEmi').txt('0').up()
+      .ele('verProc').txt('ghinfe-0.6.0').up()
+      .up();
+
+    const emit = inf.ele('emit');
+    emit.ele('CNPJ').txt(documento.emitente.cnpj.replace(/\D/g, '')).up();
+    emit.ele('xNome').txt(documento.emitente.razaoSocial).up();
+    if (documento.emitente.nomeFantasia) emit.ele('xFant').txt(documento.emitente.nomeFantasia).up();
+    this.#appendEndereco(emit, 'enderEmit', documento.emitente.endereco);
+    emit.ele('IE').txt(documento.emitente.ie).up();
+    emit.ele('CRT').txt(documento.emitente.crt).up();
+    emit.up();
+
+    const dest = inf.ele('dest');
+    const docDest = (documento.destinatario.cnpj ?? documento.destinatario.cpf ?? '').replace(/\D/g, '');
+    if (docDest.length === 14) dest.ele('CNPJ').txt(docDest).up();
+    else if (docDest.length === 11) dest.ele('CPF').txt(docDest).up();
+    dest.ele('xNome').txt(documento.destinatario.razaoSocial).up();
+    this.#appendEndereco(dest, 'enderDest', documento.destinatario.endereco);
+    if (documento.destinatario.indIEDest !== undefined) {
+      dest.ele('indIEDest').txt(String(documento.destinatario.indIEDest)).up();
+    }
+    if (documento.destinatario.ie) dest.ele('IE').txt(documento.destinatario.ie).up();
+    dest.up();
+
+    itens.forEach((item, index) => {
+      const det = inf.ele('det', { nItem: String(index + 1) });
+      const prod = det.ele('prod');
+      prod.ele('cProd').txt(item.codigo).up();
+      prod.ele('cEAN').txt(item.ean ?? 'SEM GTIN').up();
+      prod.ele('xProd').txt(item.descricao).up();
+      prod.ele('NCM').txt(item.ncm).up();
+      prod.ele('CFOP').txt(item.cfop).up();
+      prod.ele('uCom').txt(item.unidade).up();
+      prod.ele('qCom').txt(this.#decimal(item.quantidade, 4)).up();
+      prod.ele('vUnCom').txt(this.#decimal(item.valorUnitario, 10)).up();
+      prod.ele('vProd').txt(this.#decimal(item.valorTotal, 2)).up();
+      prod.ele('cEANTrib').txt(item.ean ?? 'SEM GTIN').up();
+      prod.ele('uTrib').txt(item.unidade).up();
+      prod.ele('qTrib').txt(this.#decimal(item.quantidade, 4)).up();
+      prod.ele('vUnTrib').txt(this.#decimal(item.valorUnitario, 10)).up();
+      prod.ele('indTot').txt('1').up();
+      prod.up();
+
+      const imposto = det.ele('imposto');
+      const icms = imposto.ele('ICMS').ele('ICMS00');
+      icms.ele('orig').txt('0').up();
+      icms.ele('CST').txt(item.cst ?? '00').up();
+      icms.ele('modBC').txt('0').up();
+      icms.ele('vBC').txt(this.#decimal(item.valorTotal, 2)).up();
+      icms.ele('pICMS').txt(this.#decimal(item.aliquotaIcms ?? 0, 4)).up();
+      icms.ele('vICMS').txt(this.#decimal(item.valorIcms ?? 0, 2)).up();
+      icms.up().up();
+      imposto.ele('PIS').ele('PISNT').ele('CST').txt('07').up().up().up();
+      imposto.ele('COFINS').ele('COFINSNT').ele('CST').txt('07').up().up().up();
+      if (item.reforma) appendIBSCBS(imposto, item.reforma);
+      imposto.up();
+      det.up();
+    });
+
+    const totalParent = inf.ele('total');
+    const total = totalParent.ele('ICMSTot');
+    total
+      .ele('vBC').txt(this.#decimal(totalProdutos, 2)).up()
+      .ele('vICMS').txt(this.#decimal(valorIcms, 2)).up()
+      .ele('vICMSDeson').txt('0.00').up()
+      .ele('vFCP').txt('0.00').up()
+      .ele('vBCST').txt('0.00').up()
+      .ele('vST').txt('0.00').up()
+      .ele('vFCPST').txt('0.00').up()
+      .ele('vFCPSTRet').txt('0.00').up()
+      .ele('vProd').txt(this.#decimal(totalProdutos, 2)).up()
+      .ele('vFrete').txt(this.#decimal(valorFrete, 2)).up()
+      .ele('vSeg').txt('0.00').up()
+      .ele('vDesc').txt('0.00').up()
+      .ele('vII').txt('0.00').up()
+      .ele('vIPI').txt('0.00').up()
+      .ele('vIPIDevol').txt('0.00').up()
+      .ele('vPIS').txt('0.00').up()
+      .ele('vCOFINS').txt('0.00').up()
+      .ele('vOutro').txt('0.00').up()
+      .ele('vNF').txt(this.#decimal(valorNf, 2)).up();
+    total.up();
+    if (totaisReforma) appendTotaisIBSCBS(totalParent, totaisReforma);
+    totalParent.up();
+
+    const transp = inf.ele('transp');
+    transp.ele('modFrete').txt(String(documento.frete?.modalidade ?? 9)).up();
+    if (documento.frete?.transportadora) {
+      const transporta = transp.ele('transporta');
+      if (documento.frete.cnpjTransportadora) {
+        transporta.ele('CNPJ').txt(documento.frete.cnpjTransportadora.replace(/\D/g, '')).up();
+      }
+      transporta.ele('xNome').txt(documento.frete.transportadora).up();
+      transporta.up();
+    }
+    transp.up();
+
+    const pag = inf.ele('pag');
+    (documento.pagamentos ?? [{ forma: '01', valor: valorNf }]).forEach((p) => {
+      const detPag = pag.ele('detPag');
+      detPag.ele('tPag').txt(p.forma).up();
+      detPag.ele('vPag').txt(this.#decimal(p.valor, 2)).up();
+      detPag.up();
+    });
+    pag.up();
+
+    if (documento.informacoesComplementares) {
+      inf.ele('infAdic').ele('infCpl').txt(documento.informacoesComplementares).up().up();
+    }
+
+    return root.end({ prettyPrint: false, headless: false });
+  }
+
+  #validar(documento) {
+    if (!documento.chaveAcesso || documento.chaveAcesso.length !== 44) {
+      throw new GhinfeError('chaveAcesso deve conter 44 dígitos', 'INVALID_CHAVE');
+    }
+    if (!documento.emitente?.cnpj) throw new GhinfeError('emitente.cnpj é obrigatório', 'INVALID_EMITENTE');
+    if (!documento.itens?.length) throw new GhinfeError('A NF-e deve conter ao menos um item', 'INVALID_ITENS');
+  }
+
+  #appendEndereco(parent, tag, endereco) {
+    const node = parent.ele(tag);
+    node.ele('xLgr').txt(endereco.logradouro).up();
+    node.ele('nro').txt(endereco.numero).up();
+    if (endereco.complemento) node.ele('xCpl').txt(endereco.complemento).up();
+    node.ele('xBairro').txt(endereco.bairro).up();
+    node.ele('cMun').txt(endereco.codigoMunicipio).up();
+    node.ele('xMun').txt(endereco.municipio).up();
+    node.ele('UF').txt(endereco.uf).up();
+    node.ele('CEP').txt(endereco.cep.replace(/\D/g, '')).up();
+    if (endereco.telefone) node.ele('fone').txt(endereco.telefone.replace(/\D/g, '')).up();
+    node.up();
+  }
+
+  #codigoUf(uf) {
+    const map = {
+      AC: '12', AL: '27', AM: '13', AP: '16', BA: '29', CE: '23', DF: '53',
+      ES: '32', GO: '52', MA: '21', MG: '31', MS: '50', MT: '51', PA: '15',
+      PB: '25', PE: '26', PI: '22', PR: '41', RJ: '33', RN: '24', RO: '11',
+      RR: '14', RS: '43', SC: '42', SE: '28', SP: '35', TO: '17',
+    };
+    return map[uf.toUpperCase()] ?? '35';
+  }
+
+  #decimal(value, decimals) {
+    return Number(value).toFixed(decimals);
+  }
+}