@bitize/bitmde 0.19.0 → 0.20.0

package/dist/validators/chaveNfse-validator.d.ts

@@ -0,0 +1,14 @@
+declare const _exports: typeof ChaveNfseValidator;
+export = _exports;
+declare class ChaveNfseValidator {
+    /**
+     *
+     * @param {string} chave
+     */
+    constructor(chave: string);
+    chave: string;
+    error: string;
+    isValid(): boolean;
+    getValues(): string;
+    getError(): string;
+}

package/dist/validators/cnpj-validator.d.ts

@@ -0,0 +1,19 @@
+declare const _exports: typeof CnpjValidator;
+export = _exports;
+declare class CnpjValidator {
+    /**
+     *
+     * @param {Object} config
+     * @param {string} config.cnpj
+     */
+    constructor(config: {
+        cnpj: string;
+    });
+    cnpj: string;
+    error: string;
+    isValid(): boolean;
+    getValues(): {
+        cnpj: string;
+    };
+    getError(): string;
+}

package/dist/validators/index.d.ts

@@ -33,6 +33,15 @@ declare const validator: Readonly<{
             getError(): string;
         };
     };
+    ChaveNfseValidator: {
+        new (chave: string): {
+            chave: string;
+            error: string;
+            isValid(): boolean;
+            getValues(): string;
+            getError(): string;
+        };
+    };
     ChaveValidator: {
         new (chave: string): {
             chave: string;
@@ -58,6 +67,19 @@ declare const validator: Readonly<{
             getError(): string;
         };
     };
+    CnpjValidator: {
+        new (config: {
+            cnpj: string;
+        }): {
+            cnpj: string;
+            error: string;
+            isValid(): boolean;
+            getValues(): {
+                cnpj: string;
+            };
+            getError(): string;
+        };
+    };
     EventoValidator: {
         new (evento: {
             chNFe: string;
@@ -108,6 +130,34 @@ declare const validator: Readonly<{
             getError(): string;
         };
     };
+    MotivoRejeicaoValidator: {
+        new (motivo?: {
+            cMotivo: "1" | "2" | "3" | "4" | "5" | "9";
+            xMotivo?: string;
+        }): {
+            cMotivo: "1" | "2" | "3" | "4" | "5" | "9";
+            xMotivo: string;
+            error: string;
+            isValid(): boolean;
+            getValues(): {
+                cMotivo: "1" | "2" | "3" | "4" | "5" | "9";
+                xMotivo: string;
+            };
+            getError(): string;
+        };
+    };
+    NsuNfseValidator: {
+        new (nsu: string | number, opcoes?: {
+            positivo?: boolean;
+        }): {
+            nsu: string | number;
+            positivo: boolean;
+            error: string;
+            isValid(): boolean;
+            getValues(): string | number;
+            getError(): string;
+        };
+    };
     NsuValidator: {
         new (nsu: string): {
             nsu: string;

package/dist/validators/motivoRejeicao-validator.d.ts

@@ -0,0 +1,23 @@
+declare const _exports: typeof MotivoRejeicaoValidator;
+export = _exports;
+declare class MotivoRejeicaoValidator {
+    /**
+     *
+     * @param {Object} [motivo]
+     * @param {'1' | '2' | '3' | '4' | '5' | '9'} motivo.cMotivo
+     * @param {string} [motivo.xMotivo]
+     */
+    constructor(motivo?: {
+        cMotivo: "1" | "2" | "3" | "4" | "5" | "9";
+        xMotivo?: string;
+    });
+    cMotivo: "1" | "2" | "3" | "4" | "5" | "9";
+    xMotivo: string;
+    error: string;
+    isValid(): boolean;
+    getValues(): {
+        cMotivo: "1" | "2" | "3" | "4" | "5" | "9";
+        xMotivo: string;
+    };
+    getError(): string;
+}

package/dist/validators/nsuNfse-validator.d.ts

@@ -0,0 +1,20 @@
+declare const _exports: typeof NsuNfseValidator;
+export = _exports;
+declare class NsuNfseValidator {
+    /**
+     * No ADN o NSU é inteiro: sem o zero-pad do leiaute da NF-e.
+     *
+     * @param {string | number} nsu
+     * @param {Object} [opcoes]
+     * @param {boolean} [opcoes.positivo] Recusa o NSU `0`.
+     */
+    constructor(nsu: string | number, opcoes?: {
+        positivo?: boolean;
+    });
+    nsu: string | number;
+    positivo: boolean;
+    error: string;
+    isValid(): boolean;
+    getValues(): string | number;
+    getError(): string;
+}

package/lib/apis/distribuicaoNFSe-api.js

@@ -0,0 +1,59 @@
+let DistribuicaoNFSeController = require("../controllers").DistribuicaoNFSeController, {
+    AmbienteValidator,
+    CertificadoValidator,
+    ChaveNfseValidator,
+    CnpjValidator,
+    NsuNfseValidator
+} = require("../validators");
+
+class DistribuicaoNFSe {
+    constructor(r) {
+        var {
+            requestOptions: e = {},
+            httpsOptions: t = {}
+        } = r.options || {}, i = new CertificadoValidator(r), o = new AmbienteValidator(r), r = new CnpjValidator(r);
+        if (!i.isValid()) throw new Error(i.getError());
+        if (!o.isValid()) throw new Error(o.getError());
+        if (!r.isValid()) throw new Error(r.getError());
+        var {
+            cert: i,
+            key: a
+        } = i.getValues(), o = o.getValues().tpAmb, r = r.getValues().cnpj;
+        this.config = Object.freeze({
+            cnpj: r,
+            tpAmb: o,
+            cert: i,
+            key: a,
+            requestOptions: Object.freeze(e),
+            httpsOptions: Object.freeze(t)
+        }), Object.freeze(this);
+    }
+    consultaChNFSe(r) {
+        var e, r = new ChaveNfseValidator(r);
+        if (r.isValid()) return e = r.getValues(), e = {
+            ...this.config,
+            chNFSe: e
+        }, DistribuicaoNFSeController.enviar(e);
+        throw new Error(r.getError());
+    }
+    consultaNSU(r) {
+        var e, r = new NsuNfseValidator(r, {
+            positivo: !0
+        });
+        if (r.isValid()) return e = r.getValues(), e = {
+            ...this.config,
+            nsu: e
+        }, DistribuicaoNFSeController.enviar(e);
+        throw new Error(r.getError());
+    }
+    consultaUltNSU(r) {
+        var e, r = new NsuNfseValidator(r);
+        if (r.isValid()) return e = r.getValues(), e = {
+            ...this.config,
+            ultNSU: e
+        }, DistribuicaoNFSeController.enviar(e);
+        throw new Error(r.getError());
+    }
+}
+
+module.exports = DistribuicaoNFSe;

package/lib/apis/manifestacaoNFSe-api.js

@@ -0,0 +1,69 @@
+let ManifestacaoNFSeController = require("../controllers").ManifestacaoNFSeController, {
+    EVENTOS_NFSE,
+    VERSION
+} = require("../env"), Data = require("../util").Data, {
+    AmbienteValidator,
+    CertificadoValidator,
+    ChaveNfseValidator,
+    CnpjValidator,
+    MotivoRejeicaoValidator,
+    ZoneValidator
+} = require("../validators");
+
+function montarOpts(e, r, t) {
+    return {
+        ...e,
+        chNFSe: r,
+        evento: EVENTOS_NFSE[t],
+        verAplic: "bitmde/" + VERSION,
+        dhEvento: Data.toFormat(new Date(), e.timezone)
+    };
+}
+
+class ManifestacaoNFSe {
+    constructor(e) {
+        var {
+            requestOptions: r = {},
+            httpsOptions: t = {}
+        } = e.options || {}, o = new CertificadoValidator(e), a = new AmbienteValidator(e), i = new CnpjValidator(e), e = new ZoneValidator(e);
+        if (!o.isValid()) throw new Error(o.getError());
+        if (!a.isValid()) throw new Error(a.getError());
+        if (!i.isValid()) throw new Error(i.getError());
+        if (!e.isValid()) throw new Error(e.getError());
+        var {
+            cert: o,
+            key: n
+        } = o.getValues(), a = a.getValues().tpAmb, i = i.getValues().cnpj, e = e.getValues().timezone;
+        this.config = Object.freeze({
+            cnpj: i,
+            tpAmb: a,
+            timezone: e,
+            cert: o,
+            key: n,
+            requestOptions: Object.freeze(r),
+            httpsOptions: Object.freeze(t)
+        }), Object.freeze(this);
+    }
+    confirmar(e) {
+        var r, e = new ChaveNfseValidator(e);
+        if (e.isValid()) return r = montarOpts(this.config, e.getValues(), 203202), 
+        ManifestacaoNFSeController.enviar(r);
+        throw new Error(e.getError());
+    }
+    rejeitar(e, r) {
+        e = new ChaveNfseValidator(e);
+        if (!e.isValid()) throw new Error(e.getError());
+        var t, o, r = new MotivoRejeicaoValidator(r);
+        if (r.isValid()) return {
+            cMotivo: t,
+            xMotivo: o
+        } = r.getValues(), e = {
+            ...montarOpts(this.config, e.getValues(), 203206),
+            cMotivo: t,
+            xMotivo: o
+        }, ManifestacaoNFSeController.enviar(e);
+        throw new Error(r.getError());
+    }
+}
+
+module.exports = ManifestacaoNFSe;

package/lib/controllers/distribuicaoNFSe-controller.js

@@ -0,0 +1,16 @@
+let {
+    DistribuicaoNFSeHelper,
+    RetornoNfseHelper
+} = require("../helpers");
+
+class DistribuicaoNFSeController {
+    static async enviar(e) {
+        var r = DistribuicaoNFSeHelper.montarRequest(e), r = await DistribuicaoNFSeHelper.enviarConsulta(r, e), e = await DistribuicaoNFSeHelper.montarResponse(r.data, e.cnpj);
+        return RetornoNfseHelper.montarRetorno({
+            json: e,
+            retorno: r
+        });
+    }
+}
+
+module.exports = Object.freeze(DistribuicaoNFSeController);

package/lib/controllers/index.js

@@ -1,5 +1,7 @@
-let DistribuicaoController = require("./distribuicaoDFe-controller"), RecepcaoController = require("./recepcaoEvento-controller"), controller = Object.freeze({
+let DistribuicaoController = require("./distribuicaoDFe-controller"), DistribuicaoNFSeController = require("./distribuicaoNFSe-controller"), ManifestacaoNFSeController = require("./manifestacaoNFSe-controller"), RecepcaoController = require("./recepcaoEvento-controller"), controller = Object.freeze({
     DistribuicaoController: DistribuicaoController,
+    DistribuicaoNFSeController: DistribuicaoNFSeController,
+    ManifestacaoNFSeController: ManifestacaoNFSeController,
     RecepcaoController: RecepcaoController
 });
 

package/lib/controllers/manifestacaoNFSe-controller.js

@@ -0,0 +1,25 @@
+let {
+    ManifestacaoNFSeHelper,
+    RetornoNfseHelper
+} = require("../helpers");
+
+class ManifestacaoNFSeController {
+    static async enviar(e) {
+        var {
+            reqXml: a,
+            config: r
+        } = await ManifestacaoNFSeHelper.montarRequest(e), r = await ManifestacaoNFSeHelper.enviarEvento(r, e), {
+            json: e,
+            falha: o
+        } = await ManifestacaoNFSeHelper.montarResponse(r.data);
+        return RetornoNfseHelper.montarRetorno({
+            json: e,
+            falha: o,
+            retorno: r,
+            servico: "SEFIN",
+            reqXml: a
+        });
+    }
+}
+
+module.exports = Object.freeze(ManifestacaoNFSeController);

package/lib/env/index.js

@@ -1,7 +1,11 @@
 let {
     CA,
     CA_PADRAO
-} = require("./ca"), DISTRIBUICAO = require("./distribuicao").DISTRIBUICAO, EVENTOS = require("./evento").EVENTOS, RECEPCAO = require("./recepcao").RECEPCAO, CODIGOS_UF = require("./uf").CODIGOS_UF, VERSION = require("./version").VERSION, ZONES = require("./zone").ZONES;
+} = require("./ca"), DISTRIBUICAO = require("./distribuicao").DISTRIBUICAO, EVENTOS = require("./evento").EVENTOS, {
+    EVENTOS_NFSE,
+    NFSE_ADN,
+    NFSE_SEFIN
+} = require("./nfse"), RECEPCAO = require("./recepcao").RECEPCAO, CODIGOS_UF = require("./uf").CODIGOS_UF, VERSION = require("./version").VERSION, ZONES = require("./zone").ZONES;
 
 module.exports = {
     CA: CA,
@@ -9,6 +13,9 @@ module.exports = {
     CODIGOS_UF: CODIGOS_UF,
     DISTRIBUICAO: DISTRIBUICAO,
     EVENTOS: EVENTOS,
+    EVENTOS_NFSE: EVENTOS_NFSE,
+    NFSE_ADN: NFSE_ADN,
+    NFSE_SEFIN: NFSE_SEFIN,
     RECEPCAO: RECEPCAO,
     VERSION: VERSION,
     ZONES: ZONES

package/lib/env/nfse.js

@@ -0,0 +1,24 @@
+let NFSE_ADN = {
+    1: "https://adn.nfse.gov.br/contribuintes",
+    2: "https://adn.producaorestrita.nfse.gov.br/contribuintes"
+}, NFSE_SEFIN = {
+    1: "https://sefin.nfse.gov.br/SefinNacional",
+    2: "https://sefin.producaorestrita.nfse.gov.br/SefinNacional"
+}, EVENTOS_NFSE = {
+    203202: {
+        codigo: "203202",
+        elemento: "e203202",
+        xDesc: "Manifestação de NFS-e - Confirmação do Tomador"
+    },
+    203206: {
+        codigo: "203206",
+        elemento: "e203206",
+        xDesc: "Manifestação de NFS-e - Rejeição do Tomador"
+    }
+};
+
+module.exports = {
+    EVENTOS_NFSE: EVENTOS_NFSE,
+    NFSE_ADN: NFSE_ADN,
+    NFSE_SEFIN: NFSE_SEFIN
+};

package/lib/env/version.js

@@ -1,3 +1,3 @@
 module.exports = {
-    VERSION: "0.19.0"
+    VERSION: "0.20.0"
 };

package/lib/helpers/distribuicaoNFSe-helper.js

@@ -0,0 +1,128 @@
+let {
+    CA_PADRAO,
+    NFSE_ADN
+} = require("../env"), SefazService = require("../services/sefaz-service"), {
+    Gzip,
+    Xml
+} = require("../util"), PAPEIS = [ [ "toma", "tomador" ], [ "prest", "prestador" ], [ "interm", "intermediario" ] ];
+
+function ler(e, t) {
+    return t.reduce((e, t) => e && "object" == typeof e ? e[t] : void 0, e);
+}
+
+function texto(e) {
+    return null == e ? "" : String(e);
+}
+
+function normalizarMensagens(e) {
+    return Array.isArray(e) ? e.filter(e => e && "object" == typeof e).map(e => ({
+        codigo: texto(e.Codigo),
+        descricao: texto(e.Descricao),
+        complemento: texto(e.Complemento)
+    })) : [];
+}
+
+class DistribuicaoNFSeHelper {
+    static async enviarConsulta(e, t) {
+        return await new SefazService({
+            baseURL: NFSE_ADN[t.tpAmb],
+            ca: CA_PADRAO,
+            cert: t.cert,
+            key: t.key,
+            tpAmb: t.tpAmb,
+            requestOptions: t.requestOptions,
+            httpsOptions: t.httpsOptions
+        }).request(e);
+    }
+    static montarRequest(e) {
+        var t, r = {
+            Accept: "application/json"
+        };
+        return void 0 !== e.chNFSe ? {
+            method: "GET",
+            url: `/NFSe/${e.chNFSe}/Eventos`,
+            headers: r,
+            responseType: "text"
+        } : {
+            method: "GET",
+            url: "/DFe/" + ((t = void 0 !== e.nsu) ? (BigInt(e.nsu) - BigInt(1)).toString() : e.ultNSU),
+            params: {
+                lote: !t,
+                cnpjConsulta: e.cnpj
+            },
+            headers: r,
+            responseType: "text"
+        };
+    }
+    static async montarResponse(e, t) {
+        let r;
+        try {
+            r = JSON.parse(e);
+        } catch (e) {
+            return null;
+        }
+        if (!r || "object" != typeof r || Array.isArray(r) || !r.StatusProcessamento) return null;
+        var o, e = Array.isArray(r.LoteDFe) ? r.LoteDFe : [], a = [], s = [];
+        for (o of await Promise.all(e.map(e => DistribuicaoNFSeHelper.abrirArquivoXml(e, t)))) (o.error ? s : a).push(o);
+        return {
+            statusProcessamento: texto(r.StatusProcessamento),
+            tipoAmbiente: texto(r.TipoAmbiente),
+            versaoAplicativo: texto(r.VersaoAplicativo),
+            dataHoraProcessamento: texto(r.DataHoraProcessamento),
+            alertas: normalizarMensagens(r.Alertas),
+            erros: normalizarMensagens(r.Erros),
+            documentos: a,
+            documentosErros: s
+        };
+    }
+    static async abrirArquivoXml(e, t) {
+        var e = e && "object" == typeof e ? e : {}, r = texto(e.NSU), o = texto(e.ChaveAcesso), a = texto(e.TipoDocumento);
+        if (!e.ArquivoXml) return {
+            nsu: r,
+            chaveAcesso: o,
+            tipoDocumento: a,
+            error: "ArquivoXml sem conteúdo."
+        };
+        let s;
+        try {
+            s = await Gzip.unzip(e.ArquivoXml);
+        } catch (e) {
+            return {
+                nsu: r,
+                chaveAcesso: o,
+                tipoDocumento: a,
+                error: "Falha ao descompactar o ArquivoXml: " + e.message
+            };
+        }
+        let i;
+        try {
+            i = Xml.xmlToJson(s);
+        } catch (e) {
+            return {
+                nsu: r,
+                chaveAcesso: o,
+                tipoDocumento: a,
+                error: "Falha ao interpretar o XML do ArquivoXml: " + e.message
+            };
+        }
+        return {
+            nsu: r,
+            chaveAcesso: o,
+            tipoDocumento: a,
+            tipoEvento: texto(e.TipoEvento),
+            dataHoraGeracao: texto(e.DataHoraGeracao),
+            papel: DistribuicaoNFSeHelper.calcularPapel(a, i, t),
+            xml: s,
+            json: i
+        };
+    }
+    static calcularPapel(e, t, r) {
+        if ("NFSE" === e) {
+            var o, a, s = ler(t, [ "NFSe", "infNFSe", "DPS", "infDPS" ]);
+            for ([ o, a ] of PAPEIS) if (ler(s, [ o, "CNPJ" ]) === r) return a;
+        }
+        return "";
+    }
+}
+
+module.exports = Object.freeze(DistribuicaoNFSeHelper);

package/lib/helpers/index.js

@@ -1,7 +1,10 @@
-let DistribuicaoHelper = require("./distribuicaoDFe-helper"), RecepcaoHelper = require("./recepcaoEvento-helper"), RetornoHelper = require("./retorno-helper"), helper = Object.freeze({
+let DistribuicaoHelper = require("./distribuicaoDFe-helper"), DistribuicaoNFSeHelper = require("./distribuicaoNFSe-helper"), ManifestacaoNFSeHelper = require("./manifestacaoNFSe-helper"), RecepcaoHelper = require("./recepcaoEvento-helper"), RetornoHelper = require("./retorno-helper"), RetornoNfseHelper = require("./retornoNfse-helper"), helper = Object.freeze({
     DistribuicaoHelper: DistribuicaoHelper,
+    DistribuicaoNFSeHelper: DistribuicaoNFSeHelper,
+    ManifestacaoNFSeHelper: ManifestacaoNFSeHelper,
     RecepcaoHelper: RecepcaoHelper,
-    RetornoHelper: RetornoHelper
+    RetornoHelper: RetornoHelper,
+    RetornoNfseHelper: RetornoNfseHelper
 });
 
 module.exports = helper;

package/lib/helpers/manifestacaoNFSe-helper.js

@@ -0,0 +1,105 @@
+let {
+    CA_PADRAO,
+    NFSE_SEFIN
+} = require("../env"), ManifestacaoNFSeSchema = require("../schemas").ManifestacaoNFSeSchema, SefazService = require("../services/sefaz-service"), {
+    Assinatura,
+    Gzip,
+    Xml
+} = require("../util");
+
+function texto(e) {
+    return null == e ? "" : String(e);
+}
+
+function normalizarMensagens(e) {
+    return (Array.isArray(e) ? e : e ? [ e ] : []).filter(e => e && "object" == typeof e).map(e => ({
+        codigo: texto(e.codigo),
+        descricao: texto(e.descricao),
+        complemento: texto(e.complemento)
+    }));
+}
+
+class ManifestacaoNFSeHelper {
+    static async enviarEvento(e, t) {
+        return await new SefazService({
+            baseURL: NFSE_SEFIN[t.tpAmb],
+            ca: CA_PADRAO,
+            cert: t.cert,
+            key: t.key,
+            tpAmb: t.tpAmb,
+            requestOptions: t.requestOptions,
+            httpsOptions: t.httpsOptions
+        }).request(e);
+    }
+    static async montarRequest(e) {
+        var t = ManifestacaoNFSeSchema.montarSchema(e), t = Xml.jsonToXml(t), t = '<?xml version="1.0" encoding="UTF-8"?>' + Assinatura.assinarXml(e.cert, e.key, t, "infPedReg"), a = await Gzip.zip(t);
+        return {
+            reqXml: t,
+            config: {
+                method: "POST",
+                url: `/nfse/${e.chNFSe}/eventos`,
+                data: JSON.stringify({
+                    pedidoRegistroEventoXmlGZipB64: a
+                }),
+                headers: {
+                    Accept: "application/json",
+                    "Content-Type": "application/json"
+                },
+                responseType: "text"
+            }
+        };
+    }
+    static async montarResponse(e) {
+        let t;
+        try {
+            t = JSON.parse(e);
+        } catch (e) {
+            return {
+                json: null
+            };
+        }
+        var a, r;
+        return t && "object" == typeof t && !Array.isArray(t) && ("eventoXmlGZipB64" in t || "erro" in t || "erros" in t) ? (e = {
+            tipoAmbiente: texto(t.tipoAmbiente),
+            versaoAplicativo: texto(t.versaoAplicativo),
+            dataHoraProcessamento: texto(t.dataHoraProcessamento),
+            alertas: normalizarMensagens(t.alertas),
+            erros: normalizarMensagens(t.erros || t.erro),
+            evento: {}
+        }, "eventoXmlGZipB64" in t && ({
+            evento: a,
+            falha: r
+        } = await ManifestacaoNFSeHelper.abrirEvento(t.eventoXmlGZipB64), e.evento = a, 
+        r) ? {
+            json: e,
+            falha: r
+        } : {
+            json: e
+        }) : {
+            json: null
+        };
+    }
+    static async abrirEvento(e) {
+        var t = "Falha ao abrir o evento retornado: ";
+        if (!e) return {
+            evento: {},
+            falha: t + "eventoXmlGZipB64 sem conteúdo."
+        };
+        try {
+            var a = await Gzip.unzip(e);
+            return {
+                evento: {
+                    xml: a,
+                    json: Xml.xmlToJson(a)
+                }
+            };
+        } catch (e) {
+            return {
+                evento: {},
+                falha: t + e.message
+            };
+        }
+    }
+}
+
+module.exports = Object.freeze(ManifestacaoNFSeHelper);

package/lib/helpers/retornoNfse-helper.js

@@ -0,0 +1,31 @@
+let RESPOSTA_INESPERADA = {
+    ADN: "Resposta inesperada do ADN",
+    SEFIN: "Resposta inesperada da SEFIN"
+};
+
+class RetornoNfseHelper {
+    static montarRetorno(r) {
+        var {
+            json: r,
+            retorno: e,
+            servico: o = "ADN",
+            reqXml: s,
+            falha: a
+        } = r, t = e.status, n = {
+            data: r || {}
+        }, s = (void 0 !== s && (n.reqXml = s), n.resBody = e.data || "", n.status = t, 
+        RESPOSTA_INESPERADA[o] + ` (HTTP ${t}).`);
+        return e.transportError ? ({
+            code: o,
+            message: e
+        } = e.transportError, n.data = {}, n.error = `Falha de transporte (${o}): ` + e, 
+        n.transportError = {
+            code: o,
+            message: e
+        }) : r ? "NENHUM_DOCUMENTO_LOCALIZADO" !== r.statusProcessamento && (o = Array.isArray(r.erros) ? r.erros : [], 
+        2 !== Math.floor(t / 100) || "REJEICAO" === r.statusProcessamento || 0 < o.length ? n.error = o.length ? o.map(r => r.codigo + ": " + r.descricao).join("; ") : s : a && (n.error = a)) : n.error = s, 
+        n;
+    }
+}
+
+module.exports = Object.freeze(RetornoNfseHelper);