@bitize/bitmde 0.18.0 → 0.20.0

package/dist/helpers/index.d.ts

@@ -5,6 +5,10 @@ declare const helper: Readonly<{
         enviarConsulta(data: string, opts: any): Promise<{
             status: number;
             data: string;
+            transportError?: {
+                code: string;
+                message: string;
+            };
         }>;
         montarRequest(opts: any): string;
         montarResponse(data: string): Promise<{
@@ -39,11 +43,134 @@ 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<{
             status: number;
             data: string;
+            transportError?: {
+                code: string;
+                message: string;
+            };
         }>;
         montarRequest(opts: any): string;
         montarResponse(data: string): {
@@ -78,6 +205,10 @@ declare const helper: Readonly<{
             retornoSefaz: {
                 data: string;
                 status: number;
+                transportError?: {
+                    code: string;
+                    message: string;
+                };
             };
         }): {
             data: any;
@@ -86,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/recepcaoEvento-helper.d.ts

@@ -10,6 +10,10 @@ declare class RecepcaoHelper {
     static enviarEvento(data: string, opts: any): Promise<{
         status: number;
         data: string;
+        transportError?: {
+            code: string;
+            message: string;
+        };
     }>;
     /**
      *

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

@@ -9,6 +9,7 @@ declare class RetornoHelper {
      * @param {Object} options.retornoSefaz
      * @param {string} options.retornoSefaz.data
      * @param {number} options.retornoSefaz.status
+     * @param {{code: string, message: string}} [options.retornoSefaz.transportError]
      * @returns
      */
     static montarRetorno(options: {
@@ -17,6 +18,10 @@ declare class RetornoHelper {
         retornoSefaz: {
             data: string;
             status: number;
+            transportError?: {
+                code: string;
+                message: string;
+            };
         };
     }): {
         data: any;

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,11 +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/services/sefaz-service.d.ts

@@ -3,10 +3,17 @@ declare class Instance {
     constructor(opts: any);
     instance: import("axios").AxiosInstance;
     /**
-     * @returns {Promise<{status: number, data: string}>}
+     * Sem resposta HTTP (cadeia TLS, DNS, conexão recusada, timeout, erro
+     * antes do envio), devolve `status: 0` e o motivo em `transportError`.
+     *
+     * @returns {Promise<{status: number, data: string, transportError?: {code: string, message: string}}>}
      */
     request(config: any): Promise<{
         status: number;
         data: string;
+        transportError?: {
+            code: string;
+            message: string;
+        };
     }>;
 }

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: {

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;
+}