@bitize/bitmde 0.19.0 → 0.20.0

package/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 ## [Não publicado]
 
+## [0.20.0] / 2026-10-16
+
+> Acrescenta a NFS-e Nacional: distribuição pelo ADN e manifestação do tomador na SEFIN. Nada muda nas APIs de NF-e.
+
+### Adicionado
+
+- **`DistribuicaoNFSe`: distribuição de NFS-e Nacional pelo Ambiente de Dados Nacional (ADN)**, exportada nas três formas (`module.exports`, `.default`, `.mde`). Usa o mesmo certificado A1 da NF-e e consulta as NFS-e e os eventos em que o CNPJ figura:
+  - `consultaUltNSU(ultNSU)` — até 50 documentos depois do NSU informado, começando em `'0'`; fila vazia é HTTP 404 sem `error`
+  - `consultaNSU(nsu)` — o documento daquele NSU
+  - `consultaChNFSe(chNFSe)` — a NFS-e da chave de 50 dígitos e os eventos dela
+- Campo `papel` em cada NFS-e distribuída: `'tomador'`, `'prestador'` ou `'intermediario'`, conforme o CNPJ consultado apareça como `toma`, `prest` ou `interm` da DPS, nessa ordem; `''` se não aparecer e em eventos. A biblioteca marca, não filtra
+- Retorno próprio da NFS-e, `{ data, resBody, status, error?, transportError? }`: `resBody` é o corpo cru do ADN, e `status`, `error` e `transportError` têm o mesmo significado das APIs de NF-e. Ver [ADR 0016](https://github.com/bitize/bitmde/blob/main/.docs/arquitetura/decisoes/0016-retorno-proprio-da-nfse.md)
+- Hosts do ADN, de produção e produção restrita, no `test/tls-sefaz.test.js` e com isso no workflow semanal `cadeia-tls.yml`
+- **`ManifestacaoNFSe`: manifestação do tomador da NFS-e Nacional na SEFIN Nacional**, exportada nas três formas. Com o mesmo certificado A1, registra um evento por chamada:
+  - `confirmar(chNFSe)` — Confirmação do Tomador (`e203202`)
+  - `rejeitar(chNFSe, { cMotivo, xMotivo? })` — Rejeição do Tomador (`e203206`), com `cMotivo` `'1'` a `'5'` ou `'9'`; `xMotivo` de 15 a 255 caracteres, obrigatório no motivo `'9'`
+- Retorno da manifestação `{ data, reqXml, resBody, status, error?, transportError? }`, no formato da ADR 0016: `reqXml` é o `pedRegEvento` assinado e `data.evento` traz o evento registrado, em `xml` e `json`
+- Hosts da SEFIN Nacional, de produção e produção restrita, no `test/tls-sefaz.test.js` e no `cadeia-tls.yml`
+
+Nada muda em `DistribuicaoDFe` nem em `RecepcaoEvento`: o XML assinado da recepção de evento sai byte a byte igual, conferido por teste.
+
+### Modificado
+
+- Workflow `testes.yml` deixa de rodar em push e PR que só mexem em documentação (`**/*.md`, `.docs/**`, `.claude/**`, `LICENSE`). O `qualidade.yml`, com o Prettier que valida o Markdown, continua rodando sempre, e o `publicar.yml` roda a suíte antes de todo release
+
 ## [0.19.0] / 2026-10-03
 
 > Muda o comportamento padrão de transporte e deixa de suportar o Node 20; leia [Compatibilidade](#compatibilidade) antes de atualizar.

package/README.md

@@ -5,9 +5,9 @@
 [![MIT License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/bitize/bitmde/blob/main/LICENSE)
 [![Mantido pelo BitERP](https://img.shields.io/badge/mantido%20por-BitERP-0b5fff.svg)](https://www.biterp.ai)
 
-Biblioteca para consumo dos Web Services da Sefaz de Distribuição de DF-e e Evento de Manifestação do Destinatário.
+Biblioteca para consumo dos Web Services da Sefaz de Distribuição de DF-e e Evento de Manifestação do Destinatário, e da NFS-e Nacional: distribuição pelo Ambiente de Dados Nacional (ADN) e manifestação do tomador na SEFIN Nacional.
 
-Essa biblioteca permite consultar a relação das notas fiscais emitidas contra um determinado CNPJ/CPF e realizar o envio do evento de manifestação, podendo assim, baixar o XML da NF-e.
+Essa biblioteca permite consultar a relação das notas fiscais emitidas contra um determinado CNPJ/CPF e realizar o envio do evento de manifestação, podendo assim, baixar o XML da NF-e. Com o mesmo certificado, consulta as NFS-e em que o CNPJ é tomador, prestador ou intermediário, e registra a Confirmação ou a Rejeição do tomador.
 
 Desenvolvida e mantida pela equipe do **[BitERP](https://www.biterp.ai)**, onde é usada em produção para a automação da manifestação do destinatário e do download de XML de NF-e de entrada.
 
@@ -37,6 +37,10 @@ npm i @bitize/bitmde
   - Retorna o Documento Fiscal referente ao NSU informado, podendo ser um `Resumo`, uma `NF-e` ou um `Evento`
 - Envio de evento
   - Registra o evento de manifestação na nota informada (`Confirmação da Operação`, `Ciência da Operação`, `Desconhecimento da Operação` ou `Operação não Realizada`)
+- Distribuição de NFS-e Nacional
+  - Consulta por último NSU, por NSU e por chave de acesso no ADN, com o papel do CNPJ (`tomador`, `prestador` ou `intermediario`) em cada NFS-e
+- Manifestação do tomador da NFS-e Nacional
+  - Registra a `Confirmação do Tomador` ou a `Rejeição do Tomador` na SEFIN Nacional
 
 ## Distribuição de DF-e
 
@@ -348,6 +352,250 @@ console.log(manifestacao)
 // }
 ```
 
+## Distribuição de NFS-e Nacional
+
+Consulta, no Ambiente de Dados Nacional (ADN), as NFS-e e os eventos em que o CNPJ figura. A fila traz o histórico inteiro do CNPJ desde a primeira nota no ADN e mistura notas recebidas, notas emitidas e eventos de terceiros sobre umas e outras. A biblioteca **não filtra**: cada NFS-e vem com o `papel` do CNPJ consultado.
+
+> **Cobertura.** Só aparece a NFS-e que chegou ao ADN: as emitidas no Emissor Nacional e as de município cujo sistema próprio compartilha com o ADN. Nota de município que ainda não compartilha não está na distribuição, mesmo com a obrigatoriedade da LC 214/2025.
+
+### Construtor
+
+```js
+new DistribuicaoNFSe(config)
+```
+
+- `config` `<Object>`
+  - `pfx` `<Buffer>` - [OPCIONAL] - Arquivo **.pfx**. Se o `pfx` não for informado, as propriedades `cert` e `key` passam a ser obrigatórias.
+  - `passphrase` `<String>` - [OPCIONAL] - Senha do arquivo **.pfx**.
+  - `cert` `<Buffer | String>` - [OPCIONAL] - Conteúdo do _cert.pem_. Essa propriedade fica obrigatória se o `pfx` não for informado.
+  - `key` `<Buffer | String>` - [OPCIONAL] - Conteúdo do _key.pem_. Essa propriedade fica obrigatória se o `pfx` não for informado.
+  - `cnpj` `<String>` - [OBRIGATÓRIO] - CNPJ consultado, com 14 caracteres e sem pontuação (aceita o alfanumérico). Pode ser o do certificado ou o de outro estabelecimento com a mesma raiz.
+  - `tpAmb` `<String>` - [OBRIGATÓRIO] - Informar `'1'` para **Produção** ou `'2'` para **Produção restrita**.
+  - `options` `<Object>` - [OPCIONAL]
+    - `requestOptions` `<AxiosRequestConfig>` - [OPCIONAL]
+    - `httpsOptions` `<AgentOptions>` - [OPCIONAL] - Opções do `https.Agent`, mescladas por cima do padrão `{ ca: CA_PADRAO, rejectUnauthorized: true }`. Ver [Conexão com a SEFAZ](#conexão-com-a-sefaz).
+
+### Consultas
+
+| Método                   | Argumento                          | Devolve                                        |
+| :----------------------- | :--------------------------------- | :--------------------------------------------- |
+| `consultaUltNSU(ultNSU)` | NSU, 1-15 dígitos; começa em `'0'` | Até 50 documentos **depois** do NSU informado  |
+| `consultaNSU(nsu)`       | NSU, 1-15 dígitos, maior que zero  | O documento daquele NSU                        |
+| `consultaChNFSe(chNFSe)` | Chave de acesso, 50 dígitos        | A NFS-e da chave e os eventos vinculados a ela |
+
+No ADN o NSU é um inteiro, sem zeros à esquerda: `'00051'` e `51` viram `'51'`.
+
+#### Exemplo: drenar a fila
+
+```js
+const { DistribuicaoNFSe } = require('@bitize/bitmde')
+const fs = require('fs')
+
+const distribuicao = new DistribuicaoNFSe({
+  pfx: fs.readFileSync('./certificado.pfx'),
+  passphrase: 'senha',
+  cnpj: '12345678000190',
+  tpAmb: '1',
+})
+
+let ultNSU = '0' // ou o último NSU guardado
+
+while (true) {
+  const consulta = await distribuicao.consultaUltNSU(ultNSU)
+
+  if (consulta.error) {
+    throw new Error(consulta.error)
+  }
+
+  const { documentos, documentosErros } = consulta.data
+
+  // Fim da fila: HTTP 404, NENHUM_DOCUMENTO_LOCALIZADO, sem error.
+  if (documentos.length === 0 && documentosErros.length === 0) {
+    break
+  }
+
+  for (const doc of documentos) {
+    if (doc.tipoDocumento === 'NFSE' && doc.papel === 'tomador') {
+      // NFS-e recebida: doc.xml e doc.json
+    }
+  }
+
+  ultNSU = [...documentos, ...documentosErros]
+    .map((doc) => doc.nsu)
+    .sort((a, b) => Number(a) - Number(b))
+    .pop()
+}
+```
+
+O próximo pedido usa o **último NSU recebido**, sem somar 1. O ADN não bloqueia quem volta a um NSU anterior, como faz a distribuição de NF-e, mas guardar o ponteiro e escolher o intervalo entre as consultas continua sendo de quem consome.
+
+#### Retorno
+
+```js
+console.log(consulta)
+// {
+//   data: {
+//     statusProcessamento: 'DOCUMENTOS_LOCALIZADOS',
+//     tipoAmbiente: 'PRODUCAO',
+//     versaoAplicativo: '1.0.0.0',
+//     dataHoraProcessamento: '2026-10-15T10:35:14.5687887-03:00',
+//     alertas: [],
+//     erros: [],
+//     documentos: [
+//       {
+//         nsu: '1',
+//         chaveAcesso: '41000000000000000000000000000000000000000000000001',
+//         tipoDocumento: 'NFSE',
+//         tipoEvento: '',
+//         dataHoraGeracao: '2026-10-01T09:12:00',
+//         papel: 'tomador',
+//         xml: '<?xml version="1.0" encoding="utf-8"?><NFSe versao="1.01" ... </NFSe>',
+//         json: { NFSe: { ... } },
+//       },
+//       {
+//         nsu: '2',
+//         chaveAcesso: '41000000000000000000000000000000000000000000000001',
+//         tipoDocumento: 'EVENTO',
+//         tipoEvento: 'CANCELAMENTO',
+//         dataHoraGeracao: '2026-10-02T15:40:00',
+//         papel: '',
+//         xml: '<?xml version="1.0" encoding="utf-8"?><evento versao="1.01" ... </evento>',
+//         json: { evento: { ... } },
+//       },
+//     ],
+//     documentosErros: [],
+//   },
+//   resBody: '{"StatusProcessamento":"DOCUMENTOS_LOCALIZADOS", ... }',
+//   status: 200,
+// }
+```
+
+- `papel` vale `'tomador'`, `'prestador'` ou `'intermediario'` quando o `cnpj` da config é o `toma`, o `prest` ou o `interm` da DPS, testados nessa ordem; `''` quando não é nenhum, e sempre `''` em eventos. Para ficar só com as recebidas, filtre por `tipoDocumento === 'NFSE' && papel === 'tomador'`.
+- `resBody` é o corpo cru da resposta do ADN, como veio. Não há `reqXml` nem `resXml`: a consulta é um `GET` sem corpo e a resposta é JSON.
+- `documentosErros` traz, com `nsu`, `chaveAcesso`, `tipoDocumento` e `error`, os itens cujo XML não abriu: `ArquivoXml sem conteúdo.`, `Falha ao descompactar o ArquivoXml: <motivo>` ou `Falha ao interpretar o XML do ArquivoXml: <motivo>`. Eles não derrubam o lote nem preenchem o `error` de topo.
+
+#### Quando há `error`
+
+| Situação                                          | `status` | `data`                       | `error`                                            |
+| :------------------------------------------------ | :------: | :--------------------------- | :------------------------------------------------- |
+| Fila vazia, chave ou NSU sem documento            |   404    | preenchido, `documentos: []` | —                                                  |
+| Rejeição do ADN (ex.: `cnpj` de outra raiz)       |   400    | preenchido, com `erros`      | `E2243: O CNPJ informado na consulta deve ter ...` |
+| Resposta que não é do ADN (ex.: HTML de um proxy) |   real   | `{}`                         | `Resposta inesperada do ADN (HTTP 502).`           |
+| Sem resposta HTTP                                 |    0     | `{}`                         | `Falha de transporte (<code>): <message>`          |
+
+Na rejeição, `data` **não** é esvaziado: `data.erros` traz o diagnóstico em `{ codigo, descricao, complemento }`. `error` e `transportError` têm o mesmo significado da distribuição de DF-e — ver [Erro de transporte](#erro-de-transporte).
+
+## Manifestação do tomador da NFS-e Nacional
+
+Registra, na SEFIN Nacional, a Confirmação (`e203202`) ou a Rejeição (`e203206`) do tomador sobre uma NFS-e que exista no ADN. Cada chamada é **um** pedido de registro de evento, assinado com o A1 da config — não há lote.
+
+> **Evento fiscal não se desfaz.** Em produção (`tpAmb: '1'`), cada chamada aceita registra um evento vinculado à nota. Depois da Confirmação, o prestador não consegue mais cancelar a NFS-e, só substituí-la; a Rejeição só é anulada pelo município de incidência. Teste em produção restrita (`tpAmb: '2'`).
+
+### Construtor
+
+```js
+new ManifestacaoNFSe(config)
+```
+
+- `config` `<Object>`
+  - `pfx` `<Buffer>` - [OPCIONAL] - Arquivo **.pfx**. Se o `pfx` não for informado, as propriedades `cert` e `key` passam a ser obrigatórias.
+  - `passphrase` `<String>` - [OPCIONAL] - Senha do arquivo **.pfx**.
+  - `cert` `<Buffer | String>` - [OPCIONAL] - Conteúdo do _cert.pem_. Essa propriedade fica obrigatória se o `pfx` não for informado.
+  - `key` `<Buffer | String>` - [OPCIONAL] - Conteúdo do _key.pem_. Essa propriedade fica obrigatória se o `pfx` não for informado.
+  - `cnpj` `<String>` - [OBRIGATÓRIO] - CNPJ do tomador, enviado como `CNPJAutor`, com 14 caracteres e sem pontuação. Precisa ter a mesma raiz do CNPJ do certificado.
+  - `tpAmb` `<String>` - [OBRIGATÓRIO] - Informar `'1'` para **Produção** ou `'2'` para **Produção restrita**.
+  - `timezone` `<String>` - [OPCIONAL] - Fuso do `dhEvento`. Padrão `'America/Sao_Paulo'`. Ver [Lista de Timezones](#lista-de-timezones).
+  - `options` `<Object>` - [OPCIONAL]
+    - `requestOptions` `<AxiosRequestConfig>` - [OPCIONAL]
+    - `httpsOptions` `<AgentOptions>` - [OPCIONAL] - Opções do `https.Agent`, mescladas por cima do padrão `{ ca: CA_PADRAO, rejectUnauthorized: true }`. Ver [Conexão com a SEFAZ](#conexão-com-a-sefaz).
+
+### Métodos
+
+| Método                     | Argumentos                                         | Evento                             |
+| :------------------------- | :------------------------------------------------- | :--------------------------------- |
+| `confirmar(chNFSe)`        | Chave de acesso, 50 dígitos                        | `e203202` — Confirmação do Tomador |
+| `rejeitar(chNFSe, motivo)` | Chave de acesso e `motivo` `{ cMotivo, xMotivo? }` | `e203206` — Rejeição do Tomador    |
+
+Códigos de `cMotivo`:
+
+| `cMotivo` | Motivo                                                                                        |
+| :-------: | :-------------------------------------------------------------------------------------------- |
+|   `'1'`   | NFS-e em duplicidade                                                                          |
+|   `'2'`   | NFS-e já emitida pelo tomador                                                                 |
+|   `'3'`   | Não ocorrência do fato gerador                                                                |
+|   `'4'`   | Erro quanto à responsabilidade tributária                                                     |
+|   `'5'`   | Erro quanto ao valor do serviço, valor das deduções, serviço prestado ou data do fato gerador |
+|   `'9'`   | Outros — **exige `xMotivo`**                                                                  |
+
+`xMotivo` é opcional nos demais motivos e, quando informado, tem de 15 a 255 caracteres.
+
+Cada NFS-e aceita uma Confirmação e uma Rejeição do tomador. A Rejeição é aceita depois da Confirmação, e a Confirmação depois da Rejeição; repetir o mesmo evento é rejeitado (`E0861` e `E0866`).
+
+#### Exemplo
+
+```js
+const { ManifestacaoNFSe } = require('@bitize/bitmde')
+const fs = require('fs')
+
+const manifestacao = new ManifestacaoNFSe({
+  pfx: fs.readFileSync('./certificado.pfx'),
+  passphrase: 'senha',
+  cnpj: '12345678000190',
+  tpAmb: '2',
+})
+
+const confirmacao = await manifestacao.confirmar(
+  '41000000000000000000000000000000000000000000000001'
+)
+
+const rejeicao = await manifestacao.rejeitar(
+  '41000000000000000000000000000000000000000000000002',
+  { cMotivo: '9', xMotivo: 'Serviço não foi prestado.' }
+)
+
+if (rejeicao.error) {
+  console.error(rejeicao.error) // ex.: 'E0866: ...'
+}
+```
+
+#### Retorno
+
+```js
+console.log(confirmacao)
+// {
+//   data: {
+//     tipoAmbiente: '2',
+//     versaoAplicativo: 'SefinNacional_1.6.0',
+//     dataHoraProcessamento: '2026-10-16T09:26:06-03:00',
+//     alertas: [],
+//     erros: [],
+//     evento: {
+//       xml: '<evento versao="1.01" ... </evento>',
+//       json: { evento: { ... } },
+//     },
+//   },
+//   reqXml: '<?xml version="1.0" encoding="UTF-8"?><pedRegEvento xmlns="http://www.sped.fazenda.gov.br/nfse" versao="1.01"> ... </pedRegEvento>',
+//   resBody: '{"tipoAmbiente":2, ... }',
+//   status: 201,
+// }
+```
+
+- `reqXml` é o `pedRegEvento` assinado, antes do gzip — é o que se audita numa rejeição.
+- `data.evento` traz o evento registrado pela SEFIN, em `xml` e `json`.
+- `status`, `error` e `transportError` têm o mesmo significado das outras APIs.
+
+#### Quando há `error`
+
+| Situação                                            | `status` | `data`                   | `error`                                                |
+| :-------------------------------------------------- | :------: | :----------------------- | :----------------------------------------------------- |
+| Evento registrado e devolvido                       |   201    | preenchido, com `evento` | —                                                      |
+| Evento registrado, mas o retorno não abre           |   201    | preenchido, `evento: {}` | `Falha ao abrir o evento retornado: <motivo>`          |
+| Rejeição da SEFIN (ex.: nota fora do ADN)           |   400    | preenchido, com `erros`  | `E1831: O evento não pode ser recepcionado pois a ...` |
+| Resposta que não é da SEFIN (ex.: HTML de um proxy) |   real   | `{}`                     | `Resposta inesperada da SEFIN (HTTP 502).`             |
+| Sem resposta HTTP                                   |    0     | `{}`                     | `Falha de transporte (<code>): <message>`              |
+
+Na segunda linha o evento **foi registrado**: não repita o pedido; consulte a nota pela [Distribuição de NFS-e Nacional](#distribuição-de-nfs-e-nacional). `reqXml` vem em todos os casos.
+
 ## Conexão com a SEFAZ
 
 ### Validação do certificado do servidor
@@ -402,6 +650,8 @@ Quando não há resposta HTTP (falha na cadeia TLS, DNS, conexão recusada, time
 
 Uma resposta HTTP de erro da SEFAZ, como um `502` ou um `503`, chega com o status real, o corpo em `resXml` e **sem** `transportError`. Então `status: 0` significa sempre "a SEFAZ não respondeu".
 
+Na `DistribuicaoNFSe` o erro de transporte tem a mesma forma, com `resBody: ''` no lugar de `reqXml` e `resXml`. As mesmas regras de `CA_PADRAO` e `httpsOptions` valem para os hosts do ADN, que hoje servem certificado Let's Encrypt.
+
 ## Sobre o BitERP
 
 O `@bitize/bitmde` é mantido pela equipe do **[BitERP](https://www.biterp.ai)**, um ERP online que automatiza a rotina fiscal, financeira e comercial de empresas brasileiras.

package/dist/apis/distribuicaoNFSe-api.d.ts

@@ -0,0 +1,176 @@
+export = DistribuicaoNFSe;
+declare class DistribuicaoNFSe {
+    /**
+     * Distribuição de NFS-e Nacional pelo Ambiente de Dados Nacional (ADN).
+     *
+     * @param {Object} config
+     * @param {Buffer} [config.pfx]
+     * @param {string} [config.passphrase]
+     * @param {Buffer | string} [config.cert]
+     * @param {Buffer | string} [config.key]
+     * @param {string} config.cnpj CNPJ consultado, enviado como `cnpjConsulta`. Precisa ter a mesma raiz do CNPJ do certificado.
+     * @param {'1' | '2'} config.tpAmb `'1'` produção, `'2'` produção restrita.
+     * @param {Object} [config.options]
+     * @param {import('axios').AxiosRequestConfig} [config.options.requestOptions]
+     * @param {import('https').AgentOptions} [config.options.httpsOptions] Mesclado por cima do padrão `{ ca: CA_PADRAO, rejectUnauthorized: true }`. Informar `ca` substitui a cadeia inteira; para somar uma AC, use `[...CA_PADRAO, minhaCa]`.
+     */
+    constructor(config: {
+        pfx?: Buffer;
+        passphrase?: string;
+        cert?: Buffer | string;
+        key?: Buffer | string;
+        cnpj: string;
+        tpAmb: "1" | "2";
+        options?: {
+            requestOptions?: import("axios").AxiosRequestConfig;
+            httpsOptions?: import("https").AgentOptions;
+        };
+    });
+    config: Readonly<{
+        cnpj: string;
+        tpAmb: "1" | "2";
+        cert: string;
+        key: string;
+        requestOptions: Readonly<import("axios").AxiosRequestConfig<any, any>>;
+        httpsOptions: Readonly<import("node:https").AgentOptions>;
+    }>;
+    /**
+     * A NFS-e da chave e os eventos vinculados a ela.
+     *
+     * @param {string} chNFSe Chave de acesso de 50 dígitos.
+     */
+    consultaChNFSe(chNFSe: string): 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;
+    }>;
+    /**
+     * O documento daquele NSU.
+     *
+     * @param {string | number} nsu Maior que zero.
+     */
+    consultaNSU(nsu: string | number): 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;
+    }>;
+    /**
+     * Até 50 documentos depois do NSU informado. Começa em `'0'`; o pedido
+     * seguinte usa o último NSU recebido. Fila vazia é `status` 404, sem `error`.
+     *
+     * @param {string | number} ultNSU
+     */
+    consultaUltNSU(ultNSU: string | number): 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;
+    }>;
+}

package/dist/apis/manifestacaoNFSe-api.d.ts

@@ -0,0 +1,130 @@
+export = ManifestacaoNFSe;
+declare class ManifestacaoNFSe {
+    /**
+     * Manifestação do tomador da NFS-e Nacional (Confirmação e Rejeição), na
+     * SEFIN Nacional. Cada chamada registra um evento fiscal: em produção
+     * (`tpAmb` `'1'`), ele não se desfaz.
+     *
+     * @param {Object} config
+     * @param {Buffer} [config.pfx]
+     * @param {string} [config.passphrase]
+     * @param {Buffer | string} [config.cert]
+     * @param {Buffer | string} [config.key]
+     * @param {string} config.cnpj CNPJ do tomador, enviado como `CNPJAutor`. Precisa ter a mesma raiz do CNPJ do certificado.
+     * @param {'1' | '2'} config.tpAmb `'1'` produção, `'2'` produção restrita.
+     * @param {'America/Araguaina' | 'America/Bahia' | 'America/Belem' | 'America/Boa_Vista' | 'America/Campo_Grande' | 'America/Cuiaba' | 'America/Fortaleza' | 'America/Maceio' | 'America/Manaus' | 'America/Noronha' | 'America/Porto_Velho' | 'America/Recife' | 'America/Rio_Branco' | 'America/Sao_Paulo'} [config.timezone = 'America/Sao_Paulo']
+     * @param {Object} [config.options]
+     * @param {import('axios').AxiosRequestConfig} [config.options.requestOptions]
+     * @param {import('https').AgentOptions} [config.options.httpsOptions] Mesclado por cima do padrão `{ ca: CA_PADRAO, rejectUnauthorized: true }`. Informar `ca` substitui a cadeia inteira; para somar uma AC, use `[...CA_PADRAO, minhaCa]`.
+     */
+    constructor(config: {
+        pfx?: Buffer;
+        passphrase?: string;
+        cert?: Buffer | string;
+        key?: Buffer | string;
+        cnpj: string;
+        tpAmb: "1" | "2";
+        timezone?: "America/Araguaina" | "America/Bahia" | "America/Belem" | "America/Boa_Vista" | "America/Campo_Grande" | "America/Cuiaba" | "America/Fortaleza" | "America/Maceio" | "America/Manaus" | "America/Noronha" | "America/Porto_Velho" | "America/Recife" | "America/Rio_Branco" | "America/Sao_Paulo";
+        options?: {
+            requestOptions?: import("axios").AxiosRequestConfig;
+            httpsOptions?: import("https").AgentOptions;
+        };
+    });
+    config: Readonly<{
+        cnpj: string;
+        tpAmb: "1" | "2";
+        timezone: "America/Araguaina" | "America/Bahia" | "America/Belem" | "America/Boa_Vista" | "America/Campo_Grande" | "America/Cuiaba" | "America/Fortaleza" | "America/Maceio" | "America/Manaus" | "America/Noronha" | "America/Porto_Velho" | "America/Recife" | "America/Rio_Branco" | "America/Sao_Paulo";
+        cert: string;
+        key: string;
+        requestOptions: Readonly<import("axios").AxiosRequestConfig<any, any>>;
+        httpsOptions: Readonly<import("node:https").AgentOptions>;
+    }>;
+    /**
+     * Confirmação do tomador (`e203202`). Depois dela, o prestador não
+     * consegue mais cancelar a NFS-e, só substituí-la.
+     *
+     * @param {string} chNFSe Chave de acesso de 50 dígitos.
+     */
+    confirmar(chNFSe: string): 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;
+    }>;
+    /**
+     * Rejeição do tomador (`e203206`).
+     *
+     * @param {string} chNFSe Chave de acesso de 50 dígitos.
+     * @param {Object} motivo
+     * @param {MotivoRejeicaoNFSe} motivo.cMotivo
+     * @param {string} [motivo.xMotivo] De 15 a 255 caracteres; obrigatório com `cMotivo` `'9'`.
+     */
+    rejeitar(chNFSe: string, motivo: {
+        cMotivo: MotivoRejeicaoNFSe;
+        xMotivo?: string;
+    }): 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;
+    }>;
+}
+declare namespace ManifestacaoNFSe {
+    export { MotivoRejeicaoNFSe };
+}
+/**
+ * Motivo da Rejeição do tomador (`cMotivo`):
+ * - `'1'` NFS-e em duplicidade;
+ * - `'2'` NFS-e já emitida pelo tomador;
+ * - `'3'` não ocorrência do fato gerador;
+ * - `'4'` erro quanto à responsabilidade tributária;
+ * - `'5'` erro quanto ao valor do serviço, valor das deduções, serviço prestado ou data do fato gerador;
+ * - `'9'` outros — exige `xMotivo`.
+ */
+type MotivoRejeicaoNFSe = "1" | "2" | "3" | "4" | "5" | "9";

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

@@ -0,0 +1,50 @@
+declare const _exports: typeof DistribuicaoNFSeController;
+export = _exports;
+declare class DistribuicaoNFSeController {
+    /**
+     *
+     * @param {Object} opts
+     * @returns {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: Object}>, documentosErros: Array<{nsu: string,chaveAcesso: string,tipoDocumento: string,error: string}>}, error?: string, transportError?: {code: string, message: string}, resBody: string, status: number}>}
+     */
+    static 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;
+    }>;
+}