@bitize/bitmde 0.19.0 → 0.20.0

package/dist/controllers/index.d.ts

@@ -33,6 +33,82 @@ declare const controller: Readonly<{
             status: number;
         }>;
     };
+    DistribuicaoNFSeController: {
+        new (): {};
+        enviar(opts: any): Promise<{
+            data: {
+                statusProcessamento: string;
+                tipoAmbiente: string;
+                versaoAplicativo: string;
+                dataHoraProcessamento: string;
+                alertas: Array<{
+                    codigo: string;
+                    descricao: string;
+                    complemento: string;
+                }>;
+                erros: Array<{
+                    codigo: string;
+                    descricao: string;
+                    complemento: string;
+                }>;
+                documentos: Array<{
+                    nsu: string;
+                    chaveAcesso: string;
+                    tipoDocumento: string;
+                    tipoEvento: string;
+                    dataHoraGeracao: string;
+                    papel: "" | "tomador" | "prestador" | "intermediario";
+                    xml: string;
+                    json: any;
+                }>;
+                documentosErros: Array<{
+                    nsu: string;
+                    chaveAcesso: string;
+                    tipoDocumento: string;
+                    error: string;
+                }>;
+            };
+            error?: string;
+            transportError?: {
+                code: string;
+                message: string;
+            };
+            resBody: string;
+            status: number;
+        }>;
+    };
+    ManifestacaoNFSeController: {
+        new (): {};
+        enviar(opts: any): Promise<{
+            data: {
+                tipoAmbiente: string;
+                versaoAplicativo: string;
+                dataHoraProcessamento: string;
+                alertas: Array<{
+                    codigo: string;
+                    descricao: string;
+                    complemento: string;
+                }>;
+                erros: Array<{
+                    codigo: string;
+                    descricao: string;
+                    complemento: string;
+                }>;
+                evento: {
+                    xml?: string;
+                    json?: any;
+                };
+            };
+            error?: string;
+            transportError?: {
+                code: string;
+                message: string;
+            };
+            reqXml: string;
+            resBody: string;
+            status: number;
+        }>;
+    };
     RecepcaoController: {
         new (): {};
         enviar(opts: any): Promise<{

package/dist/controllers/manifestacaoNFSe-controller.d.ts

@@ -0,0 +1,38 @@
+declare const _exports: typeof ManifestacaoNFSeController;
+export = _exports;
+declare class ManifestacaoNFSeController {
+    /**
+     *
+     * @param {Object} opts
+     * @returns {Promise<{data:{tipoAmbiente: string,versaoAplicativo: string,dataHoraProcessamento: string, alertas: Array<{codigo: string,descricao: string,complemento: string}>, erros: Array<{codigo: string,descricao: string,complemento: string}>, evento: {xml?: string, json?: Object}}, error?: string, transportError?: {code: string, message: string}, reqXml: string, resBody: string, status: number}>}
+     */
+    static enviar(opts: any): Promise<{
+        data: {
+            tipoAmbiente: string;
+            versaoAplicativo: string;
+            dataHoraProcessamento: string;
+            alertas: Array<{
+                codigo: string;
+                descricao: string;
+                complemento: string;
+            }>;
+            erros: Array<{
+                codigo: string;
+                descricao: string;
+                complemento: string;
+            }>;
+            evento: {
+                xml?: string;
+                json?: any;
+            };
+        };
+        error?: string;
+        transportError?: {
+            code: string;
+            message: string;
+        };
+        reqXml: string;
+        resBody: string;
+        status: number;
+    }>;
+}

package/dist/env/index.d.ts

@@ -3,7 +3,10 @@ import { CA_PADRAO } from "./ca";
 import { CODIGOS_UF } from "./uf";
 import { DISTRIBUICAO } from "./distribuicao";
 import { EVENTOS } from "./evento";
+import { EVENTOS_NFSE } from "./nfse";
+import { NFSE_ADN } from "./nfse";
+import { NFSE_SEFIN } from "./nfse";
 import { RECEPCAO } from "./recepcao";
 import { VERSION } from "./version";
 import { ZONES } from "./zone";
-export { CA, CA_PADRAO, CODIGOS_UF, DISTRIBUICAO, EVENTOS, RECEPCAO, VERSION, ZONES };
+export { CA, CA_PADRAO, CODIGOS_UF, DISTRIBUICAO, EVENTOS, EVENTOS_NFSE, NFSE_ADN, NFSE_SEFIN, RECEPCAO, VERSION, ZONES };

package/dist/env/nfse.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Eventos de manifestação do tomador. O `xDesc` é literal do XSD
+ * (`enumeration`), com acento: alterar o texto rejeita o pedido por schema.
+ */
+export const EVENTOS_NFSE: {
+    203202: {
+        codigo: string;
+        elemento: string;
+        xDesc: string;
+    };
+    203206: {
+        codigo: string;
+        elemento: string;
+        xDesc: string;
+    };
+};
+/**
+ * URL base da API de distribuição para contribuintes da NFS-e Nacional
+ * Ambiente de Dados Nacional (ADN) — Manual dos Contribuintes, APIs do ADN v1.0
+ */
+export const NFSE_ADN: {
+    1: string;
+    2: string;
+};
+/**
+ * URL base da API da SEFIN Nacional, que recebe o pedido de registro de evento
+ * (manifestação do tomador) — Swagger SEFIN Nacional v1
+ */
+export const NFSE_SEFIN: {
+    1: string;
+    2: string;
+};

package/dist/helpers/distribuicaoNFSe-helper.d.ts

@@ -0,0 +1,107 @@
+declare const _exports: typeof DistribuicaoNFSeHelper;
+export = _exports;
+declare class DistribuicaoNFSeHelper {
+    /**
+     *
+     * @param {Object} config
+     * @param {Object} opts
+     * @returns {Promise<{status: number, data: string, transportError?: {code: string, message: string}}>}
+     */
+    static enviarConsulta(config: any, opts: any): Promise<{
+        status: number;
+        data: string;
+        transportError?: {
+            code: string;
+            message: string;
+        };
+    }>;
+    /**
+     * Config da requisição ao axios. Os headers vão na requisição, e não na
+     * instância, para o axios mesclá-los com o User-Agent.
+     *
+     * @param {Object} opts
+     * @returns {{method: string, url: string, params?: {lote: boolean, cnpjConsulta: string}, headers: Object, responseType: string}}
+     */
+    static montarRequest(opts: any): {
+        method: string;
+        url: string;
+        params?: {
+            lote: boolean;
+            cnpjConsulta: string;
+        };
+        headers: any;
+        responseType: string;
+    };
+    /**
+     * Interpreta o corpo cru do ADN. Nunca lança: corpo que não é JSON, ou
+     * JSON sem `StatusProcessamento`, devolve `null`.
+     *
+     * @param {string} corpo
+     * @param {string} cnpj CNPJ consultado, para o `papel` de cada NFS-e
+     * @returns {Promise<{statusProcessamento: string, tipoAmbiente: string, versaoAplicativo: string, dataHoraProcessamento: string, alertas: {codigo: string, descricao: string, complemento: string}[], erros: {codigo: string, descricao: string, complemento: string}[], documentos: {nsu: string, chaveAcesso: string, tipoDocumento: string, tipoEvento: string, dataHoraGeracao: string, papel: string, xml: string, json: Object}[], documentosErros: {nsu: string, chaveAcesso: string, tipoDocumento: string, error: string}[]} | null>}
+     */
+    static montarResponse(corpo: string, cnpj: string): Promise<{
+        statusProcessamento: string;
+        tipoAmbiente: string;
+        versaoAplicativo: string;
+        dataHoraProcessamento: string;
+        alertas: {
+            codigo: string;
+            descricao: string;
+            complemento: string;
+        }[];
+        erros: {
+            codigo: string;
+            descricao: string;
+            complemento: string;
+        }[];
+        documentos: {
+            nsu: string;
+            chaveAcesso: string;
+            tipoDocumento: string;
+            tipoEvento: string;
+            dataHoraGeracao: string;
+            papel: string;
+            xml: string;
+            json: any;
+        }[];
+        documentosErros: {
+            nsu: string;
+            chaveAcesso: string;
+            tipoDocumento: string;
+            error: string;
+        }[];
+    } | null>;
+    /**
+     * Descompacta e interpreta um item do `LoteDFe` sem nunca rejeitar: a
+     * falha vira um item com `error`, para não derrubar o restante do lote.
+     *
+     * @param {Object} item
+     * @param {string} cnpj
+     * @returns {Promise<{nsu: string, chaveAcesso: string, tipoDocumento: string, tipoEvento: string, dataHoraGeracao: string, papel: string, xml: string, json: Object} | {nsu: string, chaveAcesso: string, tipoDocumento: string, error: string}>}
+     */
+    static abrirArquivoXml(item: any, cnpj: string): Promise<{
+        nsu: string;
+        chaveAcesso: string;
+        tipoDocumento: string;
+        tipoEvento: string;
+        dataHoraGeracao: string;
+        papel: string;
+        xml: string;
+        json: any;
+    } | {
+        nsu: string;
+        chaveAcesso: string;
+        tipoDocumento: string;
+        error: string;
+    }>;
+    /**
+     * Papel do CNPJ consultado na NFS-e. Evento não traz as partes da nota.
+     *
+     * @param {string} tipoDocumento
+     * @param {Object} json
+     * @param {string} cnpj
+     * @returns {'' | 'tomador' | 'prestador' | 'intermediario'}
+     */
+    static calcularPapel(tipoDocumento: string, json: any, cnpj: string): "" | "tomador" | "prestador" | "intermediario";
+}

package/dist/helpers/index.d.ts

@@ -43,6 +43,125 @@ declare const helper: Readonly<{
             error: string;
         }>;
     };
+    DistribuicaoNFSeHelper: {
+        new (): {};
+        enviarConsulta(config: any, opts: any): Promise<{
+            status: number;
+            data: string;
+            transportError?: {
+                code: string;
+                message: string;
+            };
+        }>;
+        montarRequest(opts: any): {
+            method: string;
+            url: string;
+            params?: {
+                lote: boolean;
+                cnpjConsulta: string;
+            };
+            headers: any;
+            responseType: string;
+        };
+        montarResponse(corpo: string, cnpj: string): Promise<{
+            statusProcessamento: string;
+            tipoAmbiente: string;
+            versaoAplicativo: string;
+            dataHoraProcessamento: string;
+            alertas: {
+                codigo: string;
+                descricao: string;
+                complemento: string;
+            }[];
+            erros: {
+                codigo: string;
+                descricao: string;
+                complemento: string;
+            }[];
+            documentos: {
+                nsu: string;
+                chaveAcesso: string;
+                tipoDocumento: string;
+                tipoEvento: string;
+                dataHoraGeracao: string;
+                papel: string;
+                xml: string;
+                json: any;
+            }[];
+            documentosErros: {
+                nsu: string;
+                chaveAcesso: string;
+                tipoDocumento: string;
+                error: string;
+            }[];
+        } | null>;
+        abrirArquivoXml(item: any, cnpj: string): Promise<{
+            nsu: string;
+            chaveAcesso: string;
+            tipoDocumento: string;
+            tipoEvento: string;
+            dataHoraGeracao: string;
+            papel: string;
+            xml: string;
+            json: any;
+        } | {
+            nsu: string;
+            chaveAcesso: string;
+            tipoDocumento: string;
+            error: string;
+        }>;
+        calcularPapel(tipoDocumento: string, json: any, cnpj: string): "" | "tomador" | "prestador" | "intermediario";
+    };
+    ManifestacaoNFSeHelper: {
+        new (): {};
+        enviarEvento(config: any, opts: any): Promise<{
+            status: number;
+            data: string;
+            transportError?: {
+                code: string;
+                message: string;
+            };
+        }>;
+        montarRequest(opts: any): Promise<{
+            reqXml: string;
+            config: {
+                method: string;
+                url: string;
+                data: string;
+                headers: any;
+                responseType: string;
+            };
+        }>;
+        montarResponse(corpo: string): Promise<{
+            json: {
+                tipoAmbiente: string;
+                versaoAplicativo: string;
+                dataHoraProcessamento: string;
+                alertas: {
+                    codigo: string;
+                    descricao: string;
+                    complemento: string;
+                }[];
+                erros: {
+                    codigo: string;
+                    descricao: string;
+                    complemento: string;
+                }[];
+                evento: {
+                    xml?: string;
+                    json?: any;
+                };
+            } | null;
+            falha?: string;
+        }>;
+        abrirEvento(eventoXmlGZipB64: string): Promise<{
+            evento: {
+                xml?: string;
+                json?: any;
+            };
+            falha?: string;
+        }>;
+    };
     RecepcaoHelper: {
         new (): {};
         enviarEvento(data: string, opts: any): Promise<{
@@ -98,4 +217,31 @@ declare const helper: Readonly<{
             status: number;
         };
     };
+    RetornoNfseHelper: {
+        new (): {};
+        montarRetorno(options: {
+            json: any | null;
+            retorno: {
+                data: string;
+                status: number;
+                transportError?: {
+                    code: string;
+                    message: string;
+                };
+            };
+            servico?: "ADN" | "SEFIN";
+            reqXml?: string;
+            falha?: string;
+        }): {
+            data: any;
+            reqXml?: string;
+            resBody: string;
+            status: number;
+            error?: string;
+            transportError?: {
+                code: string;
+                message: string;
+            };
+        };
+    };
 }>;

package/dist/helpers/manifestacaoNFSe-helper.d.ts

@@ -0,0 +1,80 @@
+declare const _exports: typeof ManifestacaoNFSeHelper;
+export = _exports;
+declare class ManifestacaoNFSeHelper {
+    /**
+     *
+     * @param {Object} config
+     * @param {Object} opts
+     * @returns {Promise<{status: number, data: string, transportError?: {code: string, message: string}}>}
+     */
+    static enviarEvento(config: any, opts: any): Promise<{
+        status: number;
+        data: string;
+        transportError?: {
+            code: string;
+            message: string;
+        };
+    }>;
+    /**
+     * Monta e assina o `pedRegEvento`, e a config do `POST` ao axios. Os
+     * headers vão na requisição, e não na instância, para o axios mesclá-los
+     * com o User-Agent.
+     *
+     * @param {Object} opts
+     * @returns {Promise<{reqXml: string, config: {method: string, url: string, data: string, headers: Object, responseType: string}}>}
+     */
+    static montarRequest(opts: any): Promise<{
+        reqXml: string;
+        config: {
+            method: string;
+            url: string;
+            data: string;
+            headers: any;
+            responseType: string;
+        };
+    }>;
+    /**
+     * Interpreta o corpo cru da SEFIN. Nunca lança: corpo que não é JSON, ou
+     * JSON sem `eventoXmlGZipB64` nem `erro`, devolve `json: null`. Evento
+     * retornado que não abre devolve `falha`, que o retorno transforma em
+     * `error`.
+     *
+     * @param {string} corpo
+     * @returns {Promise<{json: {tipoAmbiente: string, versaoAplicativo: string, dataHoraProcessamento: string, alertas: {codigo: string, descricao: string, complemento: string}[], erros: {codigo: string, descricao: string, complemento: string}[], evento: {xml?: string, json?: Object}} | null, falha?: string}>}
+     */
+    static montarResponse(corpo: string): Promise<{
+        json: {
+            tipoAmbiente: string;
+            versaoAplicativo: string;
+            dataHoraProcessamento: string;
+            alertas: {
+                codigo: string;
+                descricao: string;
+                complemento: string;
+            }[];
+            erros: {
+                codigo: string;
+                descricao: string;
+                complemento: string;
+            }[];
+            evento: {
+                xml?: string;
+                json?: any;
+            };
+        } | null;
+        falha?: string;
+    }>;
+    /**
+     * Descompacta e interpreta o evento registrado, sem nunca rejeitar.
+     *
+     * @param {string} eventoXmlGZipB64
+     * @returns {Promise<{evento: {xml?: string, json?: Object}, falha?: string}>}
+     */
+    static abrirEvento(eventoXmlGZipB64: string): Promise<{
+        evento: {
+            xml?: string;
+            json?: any;
+        };
+        falha?: string;
+    }>;
+}

package/dist/helpers/retornoNfse-helper.d.ts

@@ -0,0 +1,44 @@
+declare const _exports: typeof RetornoNfseHelper;
+export = _exports;
+declare class RetornoNfseHelper {
+    /**
+     * Formato de retorno das APIs da NFS-e. `status`, `error` e
+     * `transportError` têm o mesmo significado das APIs de NF-e; o corpo cru
+     * vai em `resBody`.
+     *
+     * @param {Object} options
+     * @param {Object | null} options.json `null` quando o corpo não é uma resposta do serviço
+     * @param {Object} options.retorno
+     * @param {string} options.retorno.data
+     * @param {number} options.retorno.status
+     * @param {{code: string, message: string}} [options.retorno.transportError]
+     * @param {'ADN' | 'SEFIN'} [options.servico = 'ADN'] Nomeia o serviço na mensagem de resposta inesperada
+     * @param {string} [options.reqXml] XML de domínio enviado; só existe na manifestação
+     * @param {string} [options.falha] Falha do helper ao ler uma resposta bem-sucedida
+     * @returns {{data: Object, reqXml?: string, resBody: string, status: number, error?: string, transportError?: {code: string, message: string}}}
+     */
+    static montarRetorno(options: {
+        json: any | null;
+        retorno: {
+            data: string;
+            status: number;
+            transportError?: {
+                code: string;
+                message: string;
+            };
+        };
+        servico?: "ADN" | "SEFIN";
+        reqXml?: string;
+        falha?: string;
+    }): {
+        data: any;
+        reqXml?: string;
+        resBody: string;
+        status: number;
+        error?: string;
+        transportError?: {
+            code: string;
+            message: string;
+        };
+    };
+}

package/dist/index.d.ts

@@ -1,17 +1,23 @@
 export const CA_ICP_BRASIL: readonly string[];
 export const CA_PADRAO: readonly string[];
 import DistribuicaoDFe = require("./apis/distribuicaoDFe-api");
+import DistribuicaoNFSe = require("./apis/distribuicaoNFSe-api");
+import ManifestacaoNFSe = require("./apis/manifestacaoNFSe-api");
 import RecepcaoEvento = require("./apis/recepcaoEvento-api");
 declare namespace _default {
     export { CA_ICP_BRASIL };
     export { CA_PADRAO };
     export { DistribuicaoDFe };
+    export { DistribuicaoNFSe };
+    export { ManifestacaoNFSe };
     export { RecepcaoEvento };
 }
 export declare namespace mde {
     export { CA_ICP_BRASIL };
     export { CA_PADRAO };
     export { DistribuicaoDFe };
+    export { DistribuicaoNFSe };
+    export { ManifestacaoNFSe };
     export { RecepcaoEvento };
 }
-export { DistribuicaoDFe, RecepcaoEvento, _default as default };
+export { DistribuicaoDFe, DistribuicaoNFSe, ManifestacaoNFSe, RecepcaoEvento, _default as default };

package/dist/schemas/index.d.ts

@@ -14,6 +14,23 @@ declare const schema: Readonly<{
             };
         };
     };
+    ManifestacaoNFSeSchema: {
+        new (): {};
+        montarSchema(options: {
+            tpAmb: string;
+            verAplic: string;
+            dhEvento: string;
+            cnpj: string;
+            chNFSe: string;
+            evento: {
+                codigo: string;
+                elemento: string;
+                xDesc: string;
+            };
+            cMotivo?: string;
+            xMotivo?: string;
+        }): any;
+    };
     RecepcaoSchema: {
         new (): {};
         montarSchema(options: any): {

package/dist/schemas/manifestacaoNFSe-schema.d.ts

@@ -0,0 +1,33 @@
+declare const _exports: typeof ManifestacaoNFSeSchema;
+export = _exports;
+declare class ManifestacaoNFSeSchema {
+    /**
+     * `pedRegEvento` v1.01 de um evento do tomador. A ordem das chaves é a do
+     * `TCInfPedReg` do XSD.
+     *
+     * @param {Object} options
+     * @param {string} options.tpAmb
+     * @param {string} options.verAplic
+     * @param {string} options.dhEvento
+     * @param {string} options.cnpj
+     * @param {string} options.chNFSe
+     * @param {{codigo: string, elemento: string, xDesc: string}} options.evento
+     * @param {string} [options.cMotivo]
+     * @param {string} [options.xMotivo]
+     * @returns {Object}
+     */
+    static montarSchema(options: {
+        tpAmb: string;
+        verAplic: string;
+        dhEvento: string;
+        cnpj: string;
+        chNFSe: string;
+        evento: {
+            codigo: string;
+            elemento: string;
+            xDesc: string;
+        };
+        cMotivo?: string;
+        xMotivo?: string;
+    }): any;
+}

package/dist/util/assinatura.d.ts

@@ -2,11 +2,13 @@ declare const _exports: typeof Assinatura;
 export = _exports;
 declare class Assinatura {
     /**
+     * Assina o elemento referenciado e insere a `Signature` logo depois dele.
      *
      * @param {string} cert
      * @param {string} key
      * @param {string} xml
+     * @param {string} [elemento = 'infEvento'] `infEvento` na NF-e, `infPedReg` no pedido de evento da NFS-e
      * @returns {string}
      */
-    static assinarXml(cert: string, key: string, xml: string): string;
+    static assinarXml(cert: string, key: string, xml: string, elemento?: string): string;
 }

package/dist/util/gzip.d.ts

@@ -1,6 +1,13 @@
 declare const _exports: typeof Gzip;
 export = _exports;
 declare class Gzip {
+    /**
+     * Inverso do `unzip`: gzip do texto em UTF-8, em base64.
+     *
+     * @param {string} str
+     * @returns {Promise<string>}
+     */
+    static zip(str: string): Promise<string>;
     /**
      *
      * @param {string} str

package/dist/util/index.d.ts

@@ -2,7 +2,7 @@ export = util;
 declare const util: Readonly<{
     Assinatura: {
         new (): {};
-        assinarXml(cert: string, key: string, xml: string): string;
+        assinarXml(cert: string, key: string, xml: string, elemento?: string): string;
     };
     Certificado: {
         new (): {};
@@ -17,6 +17,7 @@ declare const util: Readonly<{
     };
     Gzip: {
         new (): {};
+        zip(str: string): Promise<string>;
         unzip(str: string): Promise<string>;
     };
     Xml: {