@sinete/nfe 0.1.0 → 0.3.0

package/src/services/gzip.ts

@@ -3,24 +3,24 @@
  * plataforma (Node 18+, Bun, Deno e browsers), sem dependência.
  */
 
-import { ProtocolError, UnsupportedError } from '@sinete/core';
-import { base64Decode } from '@sinete/core/xml';
+import { ErroNaoSuportado, ErroRespostaInvalida } from '@sinete/core';
+import { decodificarBase64 } from '@sinete/core/xml';
 
 /** Base64 de um gzip para o texto UTF-8 de dentro. */
-export async function gunzipBase64(b64: string): Promise<string> {
+export async function descomprimirGzipBase64(b64: string): Promise<string> {
   const Ds = (globalThis as { DecompressionStream?: typeof DecompressionStream }).DecompressionStream;
   if (Ds === undefined)
-    throw new UnsupportedError('DecompressionStream indisponível nesta runtime; docZip não pode ser lido');
+    throw new ErroNaoSuportado('DecompressionStream indisponível nesta runtime; docZip não pode ser lido');
   let bytes: Uint8Array<ArrayBuffer>;
   try {
-    bytes = base64Decode(b64.trim());
+    bytes = decodificarBase64(b64.trim());
   } catch (cause) {
-    throw new ProtocolError('docZip com base64 inválido', { cause });
+    throw new ErroRespostaInvalida('docZip com base64 inválido', { cause });
   }
   try {
     const stream = new Blob([bytes]).stream().pipeThrough(new Ds('gzip'));
     return await new Response(stream).text();
   } catch (cause) {
-    throw new ProtocolError('docZip não é um gzip válido', { cause });
+    throw new ErroRespostaInvalida('docZip não é um gzip válido', { cause });
   }
 }

package/src/services/index.ts

@@ -5,38 +5,40 @@
 
 export type {
   AutorDocumento,
-  AutorizacaoOutcome,
   AutorizarOpcoes,
   Cadastro,
   CadastroPedido,
   CancelamentoPedido,
   CancelamentoSubstituicaoPedido,
   CartaCorrecaoPedido,
+  ClienteNfe,
+  ClienteNfeOpcoes,
   ConsultaNfe,
-  ConsultaOutcome,
   ConsultaReciboOpcoes,
   Distribuicao,
   DistribuicaoConsulta,
   DistribuicaoOpcoes,
   DocumentoDistribuido,
-  EventoOutcome,
+  EnvioOpcoes,
+  Espera,
   EventoRegistrado,
   Inutilizacao,
-  InutilizacaoOutcome,
   InutilizacaoPedido,
   ManifestacaoPedido,
   ManifestacaoTipo,
-  NfeClient,
-  NfeClientOptions,
   PoliticaRecibo,
   ProtocoloNfe,
-  Sleep,
+  ResultadoAutorizacao,
+  ResultadoConsulta,
+  ResultadoEvento,
+  ResultadoInutilizacao,
   StatusServico,
+  StatusServicoOpcoes,
 } from './client.ts';
-export { autorizadorContingencia, createNfeClient } from './client.ts';
-export { gunzipBase64 } from './gzip.ts';
+export { autorizadorContingencia, criarClienteNfe } from './client.ts';
+export { descomprimirGzipBase64 } from './gzip.ts';
 export type { DocumentoAssinado } from './proc.ts';
-export { documentoAssinado, nfeAssinadaDoProc, sliceElement } from './proc.ts';
+export { documentoAssinado, nfeAssinadaDoProc, recortarElemento } from './proc.ts';
 export type { RecuperacaoEvento } from './recuperar.ts';
 export { recuperarEventoRegistrado } from './recuperar.ts';
 export type { ConteudoDoProtocolo, ResolucaoEnvio } from './resolver.ts';

package/src/services/outcome.ts

@@ -3,9 +3,9 @@
  * Nenhuma lista de códigos fica no código: quem decide se um `cStat` é autorização, denegação ou pendência é o dado.
  */
 
-import type { Rejected, RejectionHint, SefazStatus } from '@sinete/core';
-import { rejected } from '@sinete/core';
-import { enrichRejected } from '@sinete/rejeicoes';
+import type { DicaRejeicao, Recusado, StatusSefaz } from '@sinete/core';
+import { criarRecusado } from '@sinete/core';
+import { completarRecusado } from '@sinete/rejeicoes';
 import table from '../data/cstat.json' with { type: 'json' };
 
 /** Classes de `cStat` que a tabela descreve. */
@@ -31,7 +31,7 @@ export type CStatClasse =
   | 'consumoIndevido';
 
 const CLASSES: Readonly<Record<CStatClasse, readonly string[]>> = table;
-const DICAS: Readonly<Record<string, RejectionHint>> = table.dicas;
+const DICAS: Readonly<Record<string, DicaRejeicao>> = table.dicas;
 
 /** O `cStat` pertence à classe da tabela. */
 export function cstatEm(cStat: string, classe: CStatClasse): boolean {
@@ -39,12 +39,12 @@ export function cstatEm(cStat: string, classe: CStatClasse): boolean {
 }
 
 /**
- * Desfecho `rejected` enriquecido pelo `@sinete/rejeicoes`; sem curadoria lá, usa a dica própria do `@sinete/nfe`
+ * Desfecho `recusado` enriquecido pelo `@sinete/rejeicoes`; sem curadoria lá, usa a dica própria do `@sinete/nfe`
  * (`dicas` em `data/cstat.json`) quando houver.
  */
-export function rejeitado(status: SefazStatus): Rejected {
-  const r = enrichRejected(rejected(status));
-  if (r.hint !== undefined) return r;
+export function rejeitado(status: StatusSefaz): Recusado {
+  const r = completarRecusado(criarRecusado(status));
+  if (r.dica !== undefined) return r;
   const dica = Object.hasOwn(DICAS, status.cStat) ? DICAS[status.cStat] : undefined;
-  return dica === undefined ? r : rejected(status, dica);
+  return dica === undefined ? r : criarRecusado(status, dica);
 }

package/src/services/proc.ts

@@ -4,15 +4,15 @@
  * para gerar saída nem reserializado (invariante do repositório, ADR 0003).
  */
 
-import { ConfigError, ProtocolError } from '@sinete/core';
-import type { XmlDocument, XmlElement } from '@sinete/core/xml';
+import { ErroDeConfiguracao, ErroRespostaInvalida } from '@sinete/core';
+import type { DocumentoXml, ElementoXml } from '@sinete/core/xml';
 import {
-  attributeOf,
-  descendants,
-  firstChild,
-  inScopeNamespaces,
-  parseXml,
-  textOf,
+  atributoDe,
+  descendentes,
+  lerXml,
+  namespacesEmEscopo,
+  primeiroFilho,
+  textoDe,
   XMLDSIG_NS,
 } from '@sinete/core/xml';
 
@@ -23,11 +23,11 @@ const XML_DECL = /^?<\?xml[^?]*\?>\s*/;
 
 /**
  * Recorta o elemento da fonte, acrescentando na tag de abertura só as declarações de namespace que ele usa e que
- * estão em ancestrais fora do recorte. O default entra apenas quando difere de `parentDefaultNs` (o default do
+ * estão em ancestrais fora do recorte. O default entra apenas quando difere de `nsPadraoDoPai` (o default do
  * envelope onde a fatia vai morar).
  */
-export function sliceElement(doc: XmlDocument, el: XmlElement, parentDefaultNs: string = NFE_NS): string {
-  const slice = doc.source.slice(el.start, el.end);
+export function recortarElemento(documento: DocumentoXml, el: ElementoXml, nsPadraoDoPai: string = NFE_NS): string {
+  const slice = documento.texto.slice(el.inicio, el.fim);
   // Só os prefixos usados por algum elemento ou atributo cuja declaração está fora do recorte: um prefixo redeclarado
   // dentro dele não pode ganhar outra declaração na raiz, que mudaria o C14N inclusivo de um irmão assinado.
   //
@@ -36,39 +36,39 @@ export function sliceElement(doc: XmlDocument, el: XmlElement, parentDefaultNs:
   // protocolo vai para o proc como o leiaute pede, e é assim que o proc confere depois. Copiar para a fatia todo
   // namespace em escopo mudaria o C14N inclusivo do documento assinado pelo emitente, que nunca viu o envelope.
   const used = new Set<string>();
-  const cobertoDentro = (d: XmlElement, p: string): boolean => {
-    for (let e: XmlElement | null = d; e; e = e === el ? null : e.parent) if (e.namespaces.has(p)) return true;
+  const cobertoDentro = (d: ElementoXml, p: string): boolean => {
+    for (let e: ElementoXml | null = d; e; e = e === el ? null : e.pai) if (e.namespaces.has(p)) return true;
     return false;
   };
-  for (const d of descendants(el)) {
-    const prefixos = [d.prefix, ...d.attributes.map((a) => a.prefix)].filter((p) => p !== '' && p !== 'xml');
+  for (const d of descendentes(el)) {
+    const prefixos = [d.prefixo, ...d.atributos.map((a) => a.prefixo)].filter((p) => p !== '' && p !== 'xml');
     for (const p of prefixos) if (!cobertoDentro(d, p)) used.add(p);
   }
   const extra: string[] = [];
   const inScope = new Map<string, string>();
-  for (let e: XmlElement | null = el.parent; e; e = e.parent) {
+  for (let e: ElementoXml | null = el.pai; e; e = e.pai) {
     for (const [p, u] of e.namespaces) if (!inScope.has(p)) inScope.set(p, u);
   }
   // O default herdado de fora entra quando algum elemento sem prefixo do recorte (a raiz ou um descendente, inclusive
   // sob uma raiz prefixada) depende dele e ele difere do default do envelope de destino.
   const herdado = inScope.get('') ?? '';
-  if (herdado !== parentDefaultNs && usaDefaultHerdado(el)) extra.push(` xmlns="${herdado}"`);
+  if (herdado !== nsPadraoDoPai && usaDefaultHerdado(el)) extra.push(` xmlns="${herdado}"`);
   for (const p of [...used].sort()) {
     const uri = inScope.get(p);
-    if (uri === undefined) throw new ProtocolError(`prefixo ${p} sem declaração no recorte de ${el.name}`);
+    if (uri === undefined) throw new ErroRespostaInvalida(`prefixo ${p} sem declaração no recorte de ${el.nome}`);
     extra.push(` xmlns:${p}="${uri}"`);
   }
   if (extra.length === 0) return slice;
-  const at = 1 + el.name.length;
+  const at = 1 + el.nome.length;
   return slice.slice(0, at) + extra.join('') + slice.slice(at);
 }
 
 /** Algum elemento sem prefixo do recorte resolve o default por uma declaração de fora do recorte. */
-function usaDefaultHerdado(raiz: XmlElement): boolean {
-  for (const d of descendants(raiz)) {
-    if (d.prefix !== '') continue;
+function usaDefaultHerdado(raiz: ElementoXml): boolean {
+  for (const d of descendentes(raiz)) {
+    if (d.prefixo !== '') continue;
     let coberto = false;
-    for (let e: XmlElement | null = d; e; e = e === raiz ? null : e.parent) {
+    for (let e: ElementoXml | null = d; e; e = e === raiz ? null : e.pai) {
       if (e.namespaces.has('')) {
         coberto = true;
         break;
@@ -87,41 +87,42 @@ export interface DocumentoAssinado {
   readonly id: string;
   /** DigestValue da assinatura (base64). */
   readonly digestValue: string;
-  readonly doc: XmlDocument;
+  readonly documento: DocumentoXml;
 }
 
 /**
  * Confere que `xml` é um documento `raiz` assinado (no namespace da NF-e, com `Signature` referenciando o filho
- * `elemento`) e devolve a string sem a declaração XML. Lança `ConfigError` para qualquer outra coisa: o serviço nunca
+ * `elemento`) e devolve a string sem a declaração XML. Lança `ErroDeConfiguracao` para qualquer outra coisa: o serviço nunca
  * "conserta" o documento de quem chama.
  */
 export function documentoAssinado(xml: string, raiz: string, elemento: string): DocumentoAssinado {
   const text = xml.replace(XML_DECL, '');
-  let doc: XmlDocument;
+  let doc: DocumentoXml;
   try {
-    doc = parseXml(text);
+    doc = lerXml(text);
   } catch (cause) {
-    throw new ConfigError(`${raiz} assinado malformado`, { cause });
+    throw new ErroDeConfiguracao(`${raiz} assinado malformado`, { cause });
   }
-  if (doc.root.local !== raiz || doc.root.ns !== NFE_NS) {
-    throw new ConfigError(`esperado <${raiz}> no namespace da NF-e, veio <${doc.root.name}>`);
+  if (doc.raiz.local !== raiz || doc.raiz.ns !== NFE_NS) {
+    throw new ErroDeConfiguracao(`esperado <${raiz}> no namespace da NF-e, veio <${doc.raiz.nome}>`);
   }
   // O envelope (nfeProc, procEventoNFe) declara o default da NF-e; o C14N inclusivo herda os namespaces dos
   // ancestrais, então a raiz assinada precisa declarar ela mesma esse default, ou a assinatura deixa de conferir
   // dentro do envelope. Não se conserta o documento de quem chama: recusa.
-  if (doc.root.namespaces.get('') !== NFE_NS) {
-    throw new ConfigError(`<${raiz}> assinado precisa declarar xmlns="${NFE_NS}" na própria raiz`);
+  if (doc.raiz.namespaces.get('') !== NFE_NS) {
+    throw new ErroDeConfiguracao(`<${raiz}> assinado precisa declarar xmlns="${NFE_NS}" na própria raiz`);
   }
-  const alvo = firstChild(doc.root, elemento, NFE_NS);
-  const id = alvo ? attributeOf(alvo, 'Id') : undefined;
-  const sig = firstChild(doc.root, 'Signature', XMLDSIG_NS);
+  const alvo = primeiroFilho(doc.raiz, elemento, NFE_NS);
+  const id = alvo ? atributoDe(alvo, 'Id') : undefined;
+  const sig = primeiroFilho(doc.raiz, 'Signature', XMLDSIG_NS);
   const digest = sig && descendantText(sig, 'DigestValue');
-  if (!id || digest === undefined) throw new ConfigError(`${raiz} sem ${elemento} identificado ou sem assinatura`);
-  return { xml: text, id, digestValue: digest, doc };
+  if (!id || digest === undefined)
+    throw new ErroDeConfiguracao(`${raiz} sem ${elemento} identificado ou sem assinatura`);
+  return { xml: text, id, digestValue: digest, documento: doc };
 }
 
-function descendantText(el: XmlElement, local: string): string | undefined {
-  for (const d of descendants(el)) if (d.local === local && d.ns === XMLDSIG_NS) return textOf(d).trim();
+function descendantText(el: ElementoXml, local: string): string | undefined {
+  for (const d of descendentes(el)) if (d.local === local && d.ns === XMLDSIG_NS) return textoDe(d).trim();
   return undefined;
 }
 
@@ -130,29 +131,29 @@ function descendantText(el: XmlElement, local: string): string | undefined {
  * pronta para `consultar`, `resolverEnvioSemResposta` e a retomada, que recusam raiz sem `xmlns` próprio. O `NFe` dentro
  * do proc herda os namespaces do envelope; eles são declarados na raiz da fatia. O C14N inclusivo do `infNFe` já os
  * enxergava em escopo, então o digest e a assinatura são os mesmos dentro e fora do proc. Nada mais muda nos bytes.
- * Lança `ConfigError` quando não há NF-e assinada (proc de outro documento, NFe sem assinatura, XML malformado).
+ * Lança `ErroDeConfiguracao` quando não há NF-e assinada (proc de outro documento, NFe sem assinatura, XML malformado).
  */
 export function nfeAssinadaDoProc(xml: string): string {
   const text = xml.replace(XML_DECL, '');
-  let doc: XmlDocument;
+  let doc: DocumentoXml;
   try {
-    doc = parseXml(text);
+    doc = lerXml(text);
   } catch (cause) {
-    throw new ConfigError('nfeProc malformado', { cause });
+    throw new ErroDeConfiguracao('nfeProc malformado', { cause });
   }
   const noProc =
-    doc.root.local === 'nfeProc' && doc.root.ns === NFE_NS ? firstChild(doc.root, 'NFe', NFE_NS) : undefined;
-  const el = noProc ?? (doc.root.local === 'NFe' && doc.root.ns === NFE_NS ? doc.root : undefined);
-  if (el === undefined) throw new ConfigError(`esperado <nfeProc> ou <NFe> assinada, veio <${doc.root.name}>`);
-  const fatia = doc.source.slice(el.start, el.end);
-  const herdados = [...inScopeNamespaces(el)].filter(([p]) => p !== 'xml' && !el.namespaces.has(p));
+    doc.raiz.local === 'nfeProc' && doc.raiz.ns === NFE_NS ? primeiroFilho(doc.raiz, 'NFe', NFE_NS) : undefined;
+  const el = noProc ?? (doc.raiz.local === 'NFe' && doc.raiz.ns === NFE_NS ? doc.raiz : undefined);
+  if (el === undefined) throw new ErroDeConfiguracao(`esperado <nfeProc> ou <NFe> assinada, veio <${doc.raiz.nome}>`);
+  const fatia = doc.texto.slice(el.inicio, el.fim);
+  const herdados = [...namespacesEmEscopo(el)].filter(([p]) => p !== 'xml' && !el.namespaces.has(p));
   const decl = herdados
     .map(
       ([p, uri]) =>
         ` ${p === '' ? 'xmlns' : `xmlns:${p}`}="${uri.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/"/g, '&quot;')}"`,
     )
     .join('');
-  const at = 1 + el.name.length;
+  const at = 1 + el.nome.length;
   const assinado = decl === '' ? fatia : fatia.slice(0, at) + decl + fatia.slice(at);
   // Confere raiz, Id e assinatura como a retomada vai conferir: o que sai daqui serve direto nela.
   return documentoAssinado(assinado, 'NFe', 'infNFe').xml;

package/src/services/recuperar.ts

@@ -9,36 +9,36 @@
  * mesmo tipo.
  */
 
-import type { XmlDocument, XmlElement } from '@sinete/core/xml';
-import { firstChild, parseXml, textOf } from '@sinete/core/xml';
-import type { ConsultaOutcome, EventoRegistrado, NfeClient } from './client.ts';
+import type { DocumentoXml, ElementoXml } from '@sinete/core/xml';
+import { lerXml, primeiroFilho, textoDe } from '@sinete/core/xml';
+import type { ClienteNfe, EnvioOpcoes, EventoRegistrado, ResultadoConsulta } from './client.ts';
 import { cstatEm } from './outcome.ts';
-import { NFE_NS, sliceElement } from './proc.ts';
+import { NFE_NS, recortarElemento } from './proc.ts';
 
 /** Resultado da recuperação: o evento registrado, com a consulta que o prova, ou só a consulta. */
 export type RecuperacaoEvento =
-  | { readonly registrado: true; readonly evento: EventoRegistrado; readonly consulta: ConsultaOutcome }
-  | { readonly registrado: false; readonly consulta: ConsultaOutcome };
+  | { readonly registrado: true; readonly evento: EventoRegistrado; readonly consulta: ResultadoConsulta }
+  | { readonly registrado: false; readonly consulta: ResultadoConsulta };
 
 /** Texto do filho `local` no namespace da NF-e, se houver. */
-function campo(el: XmlElement, local: string): string | undefined {
-  const c = firstChild(el, local, NFE_NS);
-  return c === undefined ? undefined : textOf(c).trim();
+function campo(el: ElementoXml, local: string): string | undefined {
+  const c = primeiroFilho(el, local, NFE_NS);
+  return c === undefined ? undefined : textoDe(c).trim();
 }
 
 /** Lê um `procEventoNFe` da consulta; `undefined` para o que não é um evento com retorno legível. */
 function lerProcEvento(xml: string): EventoRegistrado | undefined {
-  let doc: XmlDocument;
+  let doc: DocumentoXml;
   try {
-    doc = parseXml(xml);
+    doc = lerXml(xml);
   } catch {
     return undefined;
   }
-  const evento = firstChild(doc.root, 'evento', NFE_NS);
-  const pedido = evento === undefined ? undefined : firstChild(evento, 'infEvento', NFE_NS);
-  const retEl = firstChild(doc.root, 'retEvento', NFE_NS);
-  const ret = retEl === undefined ? undefined : firstChild(retEl, 'infEvento', NFE_NS);
-  if (doc.root.local !== 'procEventoNFe' || pedido === undefined || retEl === undefined || ret === undefined) {
+  const evento = primeiroFilho(doc.raiz, 'evento', NFE_NS);
+  const pedido = evento === undefined ? undefined : primeiroFilho(evento, 'infEvento', NFE_NS);
+  const retEl = primeiroFilho(doc.raiz, 'retEvento', NFE_NS);
+  const ret = retEl === undefined ? undefined : primeiroFilho(retEl, 'infEvento', NFE_NS);
+  if (doc.raiz.local !== 'procEventoNFe' || pedido === undefined || retEl === undefined || ret === undefined) {
     return undefined;
   }
   const cStat = campo(ret, 'cStat');
@@ -62,7 +62,7 @@ function lerProcEvento(xml: string): EventoRegistrado | undefined {
     tpEvento,
     nSeqEvento: String(Number(nSeq)),
     dhRegEvento,
-    retEvento: sliceElement(doc, retEl, ''),
+    retEvento: recortarElemento(doc, retEl, ''),
     procEventoNFe: xml,
     ...(nProt === undefined ? {} : { nProt }),
   };
@@ -70,21 +70,25 @@ function lerProcEvento(xml: string): EventoRegistrado | undefined {
 
 /**
  * Consulta a chave e devolve o evento `tpEvento` que a SEFAZ registrou para ela (o de maior `nSeqEvento`, quando há
- * vários, como na CC-e). Serve depois de um pedido de evento sem resposta ou respondido com 573 ou 580: nunca conclua
- * que o evento existe só pelo `cStat` do pedido. `registrado: false` quer dizer que a consulta não mostrou o evento
- * (ou não decidiu: veja `consulta`); não quer dizer que o evento não existe.
+ * vários, como na CC-e; com `nSeqEvento`, só o dessa sequência). Serve depois de um pedido de evento sem resposta ou
+ * respondido com 573 ou 580: nunca conclua que o evento existe só pelo `cStat` do pedido. `registrado: false` quer
+ * dizer que a consulta não mostrou o evento (ou não decidiu: veja `consulta`); não quer dizer que o evento não existe.
+ * `opcoes.signal` cancela a consulta.
  */
 export async function recuperarEventoRegistrado(
-  client: NfeClient,
+  cliente: ClienteNfe,
   chave: string,
   tpEvento: string,
+  nSeqEvento?: number,
+  opcoes?: EnvioOpcoes,
 ): Promise<RecuperacaoEvento> {
-  const consulta = await client.consultar(chave);
-  if (consulta.status !== 'authorized' && consulta.status !== 'denied') return { registrado: false, consulta };
+  const consulta = await cliente.consultar(chave, undefined, opcoes);
+  if (consulta.tipo !== 'autorizado' && consulta.tipo !== 'denegado') return { registrado: false, consulta };
   let achado: EventoRegistrado | undefined;
-  for (const xml of consulta.value.eventos) {
+  for (const xml of consulta.valor.eventos) {
     const e = lerProcEvento(xml);
-    if (e === undefined || e.chNFe !== consulta.value.chNFe || e.tpEvento !== tpEvento) continue;
+    if (e === undefined || e.chNFe !== consulta.valor.chNFe || e.tpEvento !== tpEvento) continue;
+    if (nSeqEvento !== undefined && Number(e.nSeqEvento) !== nSeqEvento) continue;
     if (achado === undefined || Number(e.nSeqEvento) > Number(achado.nSeqEvento)) achado = e;
   }
   return achado === undefined ? { registrado: false, consulta } : { registrado: true, evento: achado, consulta };

package/src/services/resolver.ts

@@ -26,9 +26,9 @@
  * Acesso [chNFe: ...]") e serviço de consulta protocolo (cStat 217; 561, 562 e 613 quando a numeração tem outra NF-e).
  */
 
-import type { Rejected } from '@sinete/core';
-import { authorized, denied } from '@sinete/core';
-import type { AutorizacaoOutcome, ConsultaOutcome, NfeClient, ProtocoloNfe } from './client.ts';
+import type { Recusado } from '@sinete/core';
+import { criarAutorizado, criarDenegado } from '@sinete/core';
+import type { ClienteNfe, EnvioOpcoes, ProtocoloNfe, ResultadoAutorizacao, ResultadoConsulta } from './client.ts';
 import { cstatEm } from './outcome.ts';
 import { documentoAssinado } from './proc.ts';
 
@@ -41,15 +41,15 @@ export type ConteudoDoProtocolo = 'confere' | 'sem-digval' | 'difere';
 /** O que fazer com uma NF-e cujo envio ficou sem resposta ou voltou como duplicidade. */
 export type ResolucaoEnvio =
   /**
-   * A chave está decidida: autorizada (ou cancelada) com o mesmo conteúdo, e `outcome` traz o protocolo e o `nfeProc`;
-   * ou denegada, com qualquer conteúdo (a denegação é da chave), e `outcome` traz o protocolo, com o `nfeProc` só
+   * A chave está decidida: autorizada (ou cancelada) com o mesmo conteúdo, e `resultado` traz o protocolo e o `nfeProc`;
+   * ou denegada, com qualquer conteúdo (a denegação é da chave), e `resultado` traz o protocolo, com o `nfeProc` só
    * quando `conteudo` é `confere`.
    */
   | {
       readonly acao: 'concluida';
       readonly situacao: 'autorizada' | 'cancelada' | 'denegada';
       readonly conteudo: ConteudoDoProtocolo;
-      readonly outcome: AutorizacaoOutcome;
+      readonly resultado: ResultadoAutorizacao;
     }
   /** A NF-e não consta na SEFAZ (217): reenvie `nfeAssinada`, os mesmos bytes. */
   | { readonly acao: 'reenviar'; readonly nfeAssinada: string }
@@ -60,20 +60,20 @@ export type ResolucaoEnvio =
   | {
       readonly acao: 'divergente';
       readonly chNFe?: string;
-      readonly consulta?: ConsultaOutcome;
-      readonly motivo: Rejected | ConsultaOutcome;
+      readonly consulta?: ResultadoConsulta;
+      readonly motivo: Recusado | ResultadoConsulta;
     }
   /**
    * A chave está autorizada (ou cancelada), mas o protocolo não traz `digVal`: nada prova que o conteúdo autorizado é o
    * destes bytes. Não reenvie nem descarte a nota local, e não a guarde como autorizada sem conferir o XML registrado
    * na SEFAZ (a Distribuição DF-e ou o portal devolvem a NF-e autorizada).
    */
-  | { readonly acao: 'sem-prova'; readonly situacao: 'autorizada' | 'cancelada'; readonly consulta: ConsultaOutcome }
+  | { readonly acao: 'sem-prova'; readonly situacao: 'autorizada' | 'cancelada'; readonly consulta: ResultadoConsulta }
   /**
    * A consulta não decidiu (serviço paralisado, consumo indevido, rejeição de schema, situação sem protocolo): tente de
    * novo mais tarde, sem descartar a nota local.
    */
-  | { readonly acao: 'indefinida'; readonly outcome: ConsultaOutcome };
+  | { readonly acao: 'indefinida'; readonly resultado: ResultadoConsulta };
 
 /** Chave com CNPJ alfanumérico (NT 2025.001): 6 dígitos, 12 alfanuméricos, 26 dígitos. */
 const CHAVE_NO_MOTIVO = /\[\s*chNFe\s*:\s*([0-9]{6}[0-9A-Z]{12}[0-9]{26})\s*\]/i;
@@ -85,21 +85,23 @@ export function chaveDaDuplicidade(xMotivo: string): string | undefined {
 
 /**
  * Resolve um envio de autorização sem resposta, ou cuja resposta foi 204 ou 539, consultando a chave da NF-e
- * assinada. `anterior` é o desfecho do envio, quando houve um.
+ * assinada. `anterior` é o desfecho do envio, quando houve um. `opcoes.signal` cancela a consulta (lança o
+ * `ErroTransporte` com `code: 'cancelado'`).
  */
 export async function resolverEnvioSemResposta(
-  client: NfeClient,
+  cliente: ClienteNfe,
   nfeAssinada: string,
-  anterior?: AutorizacaoOutcome,
+  anterior?: ResultadoAutorizacao,
+  opcoes?: EnvioOpcoes,
 ): Promise<ResolucaoEnvio> {
   const a = documentoAssinado(nfeAssinada, 'NFe', 'infNFe');
   const chave = a.id.slice(3);
-  if (anterior && anterior.status === 'rejected' && cstatEm(anterior.cStat, 'duplicidadeChaveDiferente')) {
+  if (anterior && anterior.tipo === 'recusado' && cstatEm(anterior.cStat, 'duplicidadeChaveDiferente')) {
     const outra = chaveDaDuplicidade(anterior.xMotivo);
     return { acao: 'divergente', motivo: anterior, ...(outra === undefined ? {} : { chNFe: outra }) };
   }
-  const consulta = await client.consultar(chave, nfeAssinada);
-  if (consulta.status === 'rejected') {
+  const consulta = await cliente.consultar(chave, nfeAssinada, opcoes);
+  if (consulta.tipo === 'recusado') {
     if (cstatEm(consulta.cStat, 'naoConsta')) return { acao: 'reenviar', nfeAssinada: a.xml };
     // 561, 562 e 613 na consulta: a chave local não consta, mas a numeração dela tem outra NF-e (outro mês, outro cNF
     // ou outra chave). É a mesma situação da 539 no envio; o 562 traz a chave registrada no xMotivo.
@@ -107,21 +109,21 @@ export async function resolverEnvioSemResposta(
       const outra = chaveDaDuplicidade(consulta.xMotivo);
       return { acao: 'divergente', motivo: consulta, ...(outra === undefined ? {} : { chNFe: outra }) };
     }
-    return { acao: 'indefinida', outcome: consulta };
+    return { acao: 'indefinida', resultado: consulta };
   }
-  if (consulta.status === 'pending') return { acao: 'indefinida', outcome: consulta };
-  const v = consulta.value;
+  if (consulta.tipo === 'pendente') return { acao: 'indefinida', resultado: consulta };
+  const v = consulta.valor;
   const p: ProtocoloNfe | undefined = v.protocolo;
-  if (!p) return { acao: 'indefinida', outcome: consulta };
+  if (!p) return { acao: 'indefinida', resultado: consulta };
   const conteudo: ConteudoDoProtocolo =
     p.digVal === undefined ? 'sem-digval' : v.digValConfere === true ? 'confere' : 'difere';
   const protStatus = { cStat: p.cStat, xMotivo: p.xMotivo };
   // A denegação é da chave: o número está denegado com qualquer conteúdo, e o `conteudo` diz se é o destes bytes.
   if (v.situacao === 'denegada')
-    return { acao: 'concluida', situacao: 'denegada', conteudo, outcome: denied(protStatus, p) };
+    return { acao: 'concluida', situacao: 'denegada', conteudo, resultado: criarDenegado(protStatus, p) };
   // Só um digVal presente e diferente prova outro conteúdo para a chave.
   if (conteudo === 'difere') return { acao: 'divergente', chNFe: chave, consulta, motivo: consulta };
   if (conteudo === 'sem-digval') return { acao: 'sem-prova', situacao: v.situacao, consulta };
-  if (p.nfeProc === undefined) return { acao: 'indefinida', outcome: consulta };
-  return { acao: 'concluida', situacao: v.situacao, conteudo, outcome: authorized(protStatus, p) };
+  if (p.nfeProc === undefined) return { acao: 'indefinida', resultado: consulta };
+  return { acao: 'concluida', situacao: v.situacao, conteudo, resultado: criarAutorizado(protStatus, p) };
 }