@sinete/nfe 0.0.0 → 0.2.0

package/src/data/servicos.json

@@ -0,0 +1,44 @@
+{
+  "descricao": "Web services SOAP 1.2 da NF-e 4.00: namespace do WSDL e operação (a action do Content-Type é <namespace>/<operação>). Na NF-e 4.00 não existe cabeçalho nfeCabecMsg; a mensagem vai em nfeDadosMsg no namespace do WSDL, e a resposta volta em nfeResultMsg. A Distribuição DF-e usa o envelope do WSDL próprio, com nfeDadosMsg dentro de nfeDistDFeInteresse.",
+  "fonte": "MOC 7.0, Visão Geral, item 3 (padrão de comunicação e WSDL dos serviços) e WSDLs do portal da NF-e; NT 2014.002 (Distribuição DF-e)",
+  "atualizadoEm": "2026-09-28",
+  "servicos": {
+    "NfeStatusServico": {
+      "namespace": "http://www.portalfiscal.inf.br/nfe/wsdl/NFeStatusServico4",
+      "operacao": "nfeStatusServicoNF"
+    },
+    "NFeAutorizacao": {
+      "namespace": "http://www.portalfiscal.inf.br/nfe/wsdl/NFeAutorizacao4",
+      "operacao": "nfeAutorizacaoLote"
+    },
+    "NFeRetAutorizacao": {
+      "namespace": "http://www.portalfiscal.inf.br/nfe/wsdl/NFeRetAutorizacao4",
+      "operacao": "nfeRetAutorizacaoLote"
+    },
+    "NfeConsultaProtocolo": {
+      "namespace": "http://www.portalfiscal.inf.br/nfe/wsdl/NFeConsultaProtocolo4",
+      "operacao": "nfeConsultaNF"
+    },
+    "NfeInutilizacao": {
+      "namespace": "http://www.portalfiscal.inf.br/nfe/wsdl/NFeInutilizacao4",
+      "operacao": "nfeInutilizacaoNF"
+    },
+    "RecepcaoEvento": {
+      "namespace": "http://www.portalfiscal.inf.br/nfe/wsdl/NFeRecepcaoEvento4",
+      "operacao": "nfeRecepcaoEvento"
+    },
+    "NfeConsultaCadastro": {
+      "namespace": "http://www.portalfiscal.inf.br/nfe/wsdl/CadConsultaCadastro4",
+      "operacao": "consultaCadastro",
+      "envelopeNoAutorizador": {
+        "MT": "operacao"
+      },
+      "fonteEnvelope": "Resposta da SEFAZ-MT em homologação em 28/09/2026: com a mensagem só em nfeDadosMsg, o MT responde 215 (falha no schema) e devolve o retorno dentro de consultaCadastroResult; com nfeDadosMsg dentro de consultaCadastro (o elemento da operação do WSDL), responde a consulta (259)."
+    },
+    "NFeDistribuicaoDFe": {
+      "namespace": "http://www.portalfiscal.inf.br/nfe/wsdl/NFeDistribuicaoDFe",
+      "operacao": "nfeDistDFeInteresse",
+      "envelope": "distDFeInteresse"
+    }
+  }
+}

package/src/data/suframa.json

@@ -0,0 +1,7 @@
+{
+  "descricao": "Onde a inscrição na Suframa do destinatário (ISUF) é aceita na NF-e: UFs inteiras e, no Amapá, só os municípios listados. Fora delas, rejeição 251.",
+  "atualizadoEm": "2026-09-28",
+  "fonte": "MOC 7.0 Anexo I, RV E18-30 (rejeição 251, modelo 55, obrigatória)",
+  "ufs": ["AC", "AM", "RO", "RR"],
+  "municipios": { "AP": ["1600303", "1600600"] }
+}

package/src/decimal.ts

@@ -0,0 +1,232 @@
+/**
+ * Decimal exato para os valores da NF-e. Nada de `number` nas contas: um valor é `coef × 10^-scale` com `coef` em
+ * `bigint`, então soma, subtração e multiplicação são exatas e só o arredondamento, feito de propósito e com o modo
+ * escolhido, descarta dígitos.
+ *
+ * Os modos são os que os leiautes usam:
+ * - `HALF_EVEN` (arredondamento bancário, NBR 5891): o que a Calculadora da RFB aplica ao IBS e à CBS (ADR 0007).
+ * - `HALF_UP` (metade para longe do zero): o arredondamento comercial usual nos demais tributos. O MOC 7.0 Anexo I,
+ *   nota (*4) das regras de valor, só exige duas casas e aceita tolerância de R$ 0,01, sem fixar o modo.
+ * - `DOWN` (trunca em direção ao zero), para quem precisa reproduzir um sistema legado.
+ *
+ * Qual modo vale para qual campo é dado (`data/arredondamento.json`), não regra espalhada no código.
+ */
+
+import { ErroDeConfiguracao } from '@sinete/core';
+
+export type RoundingMode = 'HALF_EVEN' | 'HALF_UP' | 'DOWN';
+
+/** O que as APIs de entrada aceitam como número. Prefira `string` (`'12.34'`): `number` perde dígitos acima de 15 algarismos. */
+export type DecimalInput = string | number | bigint | Decimal;
+
+const DECIMAL_TEXT = /^([+-])?(\d+)(?:\.(\d*))?(?:[eE]([+-]?\d+))?$|^([+-])?\.(\d+)(?:[eE]([+-]?\d+))?$/;
+const MAX_SCALE = 64;
+
+function pow10(n: number): bigint {
+  return 10n ** BigInt(n);
+}
+
+/** Valor decimal imutável: `coef × 10^-scale`. */
+export class Decimal {
+  /** Coeficiente inteiro (com sinal). */
+  readonly coef: bigint;
+  /** Casas decimais do coeficiente (0 ou mais). */
+  readonly scale: number;
+
+  private constructor(coef: bigint, scale: number) {
+    this.coef = coef;
+    this.scale = scale;
+  }
+
+  static readonly ZERO: Decimal = new Decimal(0n, 0);
+  static readonly ONE: Decimal = new Decimal(1n, 0);
+  static readonly HUNDRED: Decimal = new Decimal(100n, 0);
+
+  /** Constrói a partir do coeficiente e da escala (`fromParts(1234n, 2)` = 12.34). */
+  static fromParts(coef: bigint, scale: number): Decimal {
+    if (!Number.isInteger(scale) || scale < 0 || scale > MAX_SCALE)
+      throw new ErroDeConfiguracao(`escala inválida: ${scale}`);
+    return new Decimal(coef, scale);
+  }
+
+  /**
+   * Converte a entrada. Aceita texto com ponto decimal e expoente opcional (`'12.34'`, `'1e-3'`), `number` finito e
+   * `bigint`. Vírgula, separador de milhar e espaço são recusados: o texto é a forma do XML, não a da tela.
+   */
+  static of(input: DecimalInput): Decimal {
+    const d = Decimal.tryOf(input);
+    if (d === undefined) throw new ErroDeConfiguracao(`número decimal inválido: ${JSON.stringify(String(input))}`);
+    return d;
+  }
+
+  /** Como `of`, mas devolve `undefined` em vez de lançar. */
+  static tryOf(input: DecimalInput): Decimal | undefined {
+    if (input instanceof Decimal) return input;
+    if (typeof input === 'bigint') return new Decimal(input, 0);
+    if (typeof input === 'number') {
+      if (!Number.isFinite(input)) return undefined;
+      // String(n) é a representação mais curta que volta ao mesmo double (ECMA-262 Number::toString).
+      return Decimal.tryOf(String(input));
+    }
+    if (typeof input !== 'string') return undefined;
+    const m = DECIMAL_TEXT.exec(input);
+    if (!m) return undefined;
+    const sign = (m[1] ?? m[5]) === '-' ? -1n : 1n;
+    const intPart = m[2] ?? '';
+    const frac = m[3] ?? m[6] ?? '';
+    const exp = Number(m[4] ?? m[7] ?? '0');
+    if (!Number.isSafeInteger(exp) || Math.abs(exp) > MAX_SCALE) return undefined;
+    let coef = BigInt(`${intPart}${frac}` || '0') * sign;
+    let scale = frac.length - exp;
+    if (scale < 0) {
+      coef *= pow10(-scale);
+      scale = 0;
+    }
+    if (scale > MAX_SCALE) return undefined;
+    return new Decimal(coef, scale);
+  }
+
+  private aligned(other: Decimal): [bigint, bigint, number] {
+    if (this.scale === other.scale) return [this.coef, other.coef, this.scale];
+    if (this.scale > other.scale) return [this.coef, other.coef * pow10(this.scale - other.scale), this.scale];
+    return [this.coef * pow10(other.scale - this.scale), other.coef, other.scale];
+  }
+
+  plus(other: DecimalInput): Decimal {
+    const [a, b, s] = this.aligned(Decimal.of(other));
+    return new Decimal(a + b, s);
+  }
+
+  minus(other: DecimalInput): Decimal {
+    const [a, b, s] = this.aligned(Decimal.of(other));
+    return new Decimal(a - b, s);
+  }
+
+  times(other: DecimalInput): Decimal {
+    const o = Decimal.of(other);
+    const scale = this.scale + o.scale;
+    if (scale > MAX_SCALE) {
+      // Produto de muitas casas: arredonda (HALF_EVEN) para caber, com folga muito acima de qualquer campo do leiaute.
+      return new Decimal(this.coef * o.coef, scale).round(MAX_SCALE, 'HALF_EVEN');
+    }
+    return new Decimal(this.coef * o.coef, scale);
+  }
+
+  /** Divisão com o resultado arredondado em `scale` casas pelo modo dado. */
+  dividedBy(other: DecimalInput, scale: number, mode: RoundingMode): Decimal {
+    const o = Decimal.of(other);
+    if (o.coef === 0n) throw new ErroDeConfiguracao('divisão por zero');
+    // (a / 10^sa) / (b / 10^sb) = a * 10^(sb + scale + 1 - sa) / b, com uma casa de guarda para o arredondamento.
+    const shift = o.scale + scale + 1 - this.scale;
+    const num = shift >= 0 ? this.coef * pow10(shift) : this.coef;
+    const den = shift >= 0 ? o.coef : o.coef * pow10(-shift);
+    const q = num / den;
+    const exact = q * den === num;
+    return roundCoef(q, scale + 1, scale, mode, !exact);
+  }
+
+  /** Percentual: `this × rate / 100`, sem arredondar. */
+  percent(rate: DecimalInput): Decimal {
+    const product = this.times(rate);
+    return new Decimal(product.coef, product.scale + 2);
+  }
+
+  negate(): Decimal {
+    return new Decimal(-this.coef, this.scale);
+  }
+
+  abs(): Decimal {
+    return this.coef < 0n ? this.negate() : this;
+  }
+
+  /** Arredonda para `scale` casas. Com `scale` maior que a atual, só completa com zeros. */
+  round(scale: number, mode: RoundingMode): Decimal {
+    if (!Number.isInteger(scale) || scale < 0) throw new ErroDeConfiguracao(`casas decimais inválidas: ${scale}`);
+    if (scale >= this.scale) return new Decimal(this.coef * pow10(scale - this.scale), scale);
+    return roundCoef(this.coef, this.scale, scale, mode, false);
+  }
+
+  compare(other: DecimalInput): -1 | 0 | 1 {
+    const [a, b] = this.aligned(Decimal.of(other));
+    return a < b ? -1 : a > b ? 1 : 0;
+  }
+
+  eq(other: DecimalInput): boolean {
+    return this.compare(other) === 0;
+  }
+
+  lt(other: DecimalInput): boolean {
+    return this.compare(other) < 0;
+  }
+
+  gt(other: DecimalInput): boolean {
+    return this.compare(other) > 0;
+  }
+
+  isZero(): boolean {
+    return this.coef === 0n;
+  }
+
+  isNegative(): boolean {
+    return this.coef < 0n;
+  }
+
+  /** Quantas casas decimais o valor precisa (sem os zeros à direita). */
+  significantScale(): number {
+    if (this.coef === 0n) return 0;
+    let c = this.coef;
+    let s = this.scale;
+    while (s > 0 && c % 10n === 0n) {
+      c /= 10n;
+      s--;
+    }
+    return s;
+  }
+
+  /** Texto com exatamente `scale` casas (arredonda pelo modo dado quando precisa). */
+  toFixed(scale: number, mode: RoundingMode = 'HALF_UP'): string {
+    const r = this.round(scale, mode);
+    const neg = r.coef < 0n;
+    const digits = (neg ? -r.coef : r.coef).toString().padStart(scale + 1, '0');
+    const int = digits.slice(0, digits.length - scale);
+    const frac = digits.slice(digits.length - scale);
+    return `${neg ? '-' : ''}${int}${scale > 0 ? `.${frac}` : ''}`;
+  }
+
+  /** Forma mínima, sem zeros à direita (`'12.3'`, `'0'`). */
+  toString(): string {
+    return this.toFixed(this.significantScale());
+  }
+
+  toJSON(): string {
+    return this.toString();
+  }
+}
+
+/** Reduz `coef × 10^-from` para `to` casas (`to < from`). `sticky` diz se há resto não nulo além dos dígitos dados. */
+function roundCoef(coef: bigint, from: number, to: number, mode: RoundingMode, sticky: boolean): Decimal {
+  const div = pow10(from - to);
+  const neg = coef < 0n;
+  const abs = neg ? -coef : coef;
+  let q = abs / div;
+  const r = abs % div;
+  if (mode !== 'DOWN' && (r !== 0n || sticky)) {
+    const twice = r * 2n;
+    const above = twice > div || (twice === div && sticky);
+    const tie = twice === div && !sticky;
+    if (above || (tie && (mode === 'HALF_UP' || (mode === 'HALF_EVEN' && q % 2n === 1n)))) q += 1n;
+  }
+  return Decimal.fromParts(neg ? -q : q, to);
+}
+
+/** Atalho para `Decimal.of`. */
+export function dec(valor: DecimalInput): Decimal {
+  return Decimal.of(valor);
+}
+
+/** Soma uma lista (vazia = zero). */
+export function sum(valores: Iterable<Decimal>): Decimal {
+  let acc = Decimal.ZERO;
+  for (const v of valores) acc = acc.plus(v);
+  return acc;
+}

package/src/format.ts

@@ -0,0 +1,65 @@
+/**
+ * Formatação dos decimais na forma lexical que cada tipo do leiaute aceita (ADR 0002: o número de casas vem do
+ * pattern do XSD, nunca do serializer). Cada formato abaixo cita os tipos `TDec_*` que ele cobre.
+ */
+
+import type { Decimal, RoundingMode } from './decimal.ts';
+
+export interface FormatoDecimal {
+  /** Nome curto, para mensagens. */
+  readonly nome: string;
+  /** Casas mínimas (completa com zeros até aqui). */
+  readonly min: number;
+  /** Casas máximas aceitas pelo pattern. */
+  readonly max: number;
+  /** Casas exigidas quando a parte inteira é zero e o valor não é zero (`TDec_0803v`: `0\.[0-9]{3}`). */
+  readonly minimoAbaixoDeUm?: number;
+  /** O pattern recusa zero (`TDec_1302Opc`, `TDec_0302a04Opc`): o campo zerado deve ser omitido. */
+  readonly naoNulo?: boolean;
+  /** Maior quantidade de dígitos inteiros aceita. */
+  readonly digitosInteiros: number;
+}
+
+/** `TDec_1302`, `TDec1302RTC`: 13 inteiros e exatamente 2 casas. */
+export const D1302: FormatoDecimal = { nome: 'TDec_1302', min: 2, max: 2, digitosInteiros: 13 };
+/** `TDec_1302Opc`: como `TDec_1302`, sem zero. */
+export const D1302_OPC: FormatoDecimal = { nome: 'TDec_1302Opc', min: 2, max: 2, digitosInteiros: 13, naoNulo: true };
+/** `TDec_0302a04`, `TDec_0302_04RTC`, `TDec_0302a04Max100`: 3 inteiros e 2 a 4 casas. */
+export const D0302A04: FormatoDecimal = { nome: 'TDec_0302a04', min: 2, max: 4, digitosInteiros: 3 };
+/** `TDec_0302a04Opc`: o pattern (`0\.[0-9]{2,4}|...`) aceita zero, ao contrário de `TDec_1302Opc`. */
+export const D0302A04_OPC: FormatoDecimal = { nome: 'TDec_0302a04Opc', min: 2, max: 4, digitosInteiros: 3 };
+/** `TDec_0302Max100`: 2 casas exatas. */
+export const D0302: FormatoDecimal = { nome: 'TDec_0302Max100', min: 2, max: 2, digitosInteiros: 3 };
+/** `TDec_1104v`: 11 inteiros e 0 a 4 casas. */
+export const D1104V: FormatoDecimal = { nome: 'TDec_1104v', min: 0, max: 4, digitosInteiros: 11 };
+/** `TDec_1104`, `TDec1104RTC`: 11 inteiros e 4 casas. */
+export const D1104: FormatoDecimal = { nome: 'TDec_1104', min: 4, max: 4, digitosInteiros: 11 };
+/** `TDec_1110v`: 11 inteiros e 0 a 10 casas. */
+export const D1110V: FormatoDecimal = { nome: 'TDec_1110v', min: 0, max: 10, digitosInteiros: 11 };
+/** `TDec_1204v`: 12 inteiros e 0 a 4 casas. */
+export const D1204V: FormatoDecimal = { nome: 'TDec_1204v', min: 0, max: 4, digitosInteiros: 12 };
+/** `TDec_1204`: 12 inteiros e 4 casas quando há fração (4 fixas aqui, que o pattern aceita sempre). */
+export const D1204: FormatoDecimal = { nome: 'TDec_1204', min: 4, max: 4, digitosInteiros: 12 };
+/** `TDec_1203`: 12 inteiros e 3 casas. */
+export const D1203: FormatoDecimal = { nome: 'TDec_1203', min: 3, max: 3, digitosInteiros: 12 };
+/** `TDec_0803v`: 8 inteiros e até 3 casas; abaixo de 1, exatamente 3. */
+export const D0803V: FormatoDecimal = { nome: 'TDec_0803v', min: 0, max: 3, digitosInteiros: 8, minimoAbaixoDeUm: 3 };
+
+/** Texto do valor já arredondado no formato (arredonda em `max` casas pelo modo dado). */
+export function formatarDecimal(valor: Decimal, formato: FormatoDecimal, modo: RoundingMode = 'HALF_UP'): string {
+  const r = valor.round(formato.max, modo);
+  let places = Math.max(formato.min, Math.min(formato.max, r.significantScale()));
+  if (formato.minimoAbaixoDeUm !== undefined && !r.isZero() && r.abs().lt(1))
+    places = Math.max(places, formato.minimoAbaixoDeUm);
+  return r.toFixed(places, modo);
+}
+
+/** Por que o valor não cabe no formato, ou `undefined` se cabe sem perder dígitos. */
+export function problemaDeFormato(valor: Decimal, formato: FormatoDecimal): string | undefined {
+  if (valor.isNegative()) return 'valor negativo';
+  if (formato.naoNulo && valor.isZero()) return 'valor zero não é aceito neste campo';
+  if (valor.significantScale() > formato.max) return `mais de ${formato.max} casas decimais`;
+  const intDigits = valor.round(0, 'DOWN').abs().toString().replace(/^0$/, '').length;
+  if (intDigits > formato.digitosInteiros) return `mais de ${formato.digitosInteiros} dígitos inteiros`;
+  return undefined;
+}

package/src/ibs-cbs.ts

@@ -0,0 +1,89 @@
+/**
+ * `@sinete/nfe/ibs-cbs`: tudo o que quem emite NF-e precisa do IBS/CBS, sem importar `@sinete/ibs-cbs` nem
+ * `@sinete/ibs-cbs-dados` diretamente.
+ *
+ * Reexporta o motor inteiro (`@sinete/ibs-cbs`: alíquotas, cálculo, regras da NT 2025.002 e determinação de CST e
+ * cClassTrib) e o leitor do dataset (`@sinete/ibs-cbs-dados`: `carregarDataset`, `conferirDataset`, diff, tipos). O dataset
+ * embarcado não entra aqui, para não ir para o bundle de quem não o usa: `carregarDatasetEmbarcado()`, na raiz do
+ * `@sinete/nfe`, o importa sob demanda. `Dec`, `DataIso` e `Vigencia` vêm do motor (os de `Dec` e `DataIso` são os
+ * mesmos; a `Vigencia` dos dados, com os campos do dataset, fica acessível pelos tipos que a usam).
+ */
+
+// biome-ignore lint/performance/noReExportAll: o subpath existe para reexportar o motor inteiro, e as duas pontas são do mesmo repo.
+export * from '@sinete/ibs-cbs';
+export type {
+  AliquotasCredPres,
+  Aplicabilidade,
+  BaseLegal,
+  BaseLegalClassTrib,
+  BundleDoDataset,
+  CalculoCredPres,
+  CodigoErroDadosIbsCbs,
+  ConteudoTributario,
+  CreditoClassTrib,
+  CredPresVigente,
+  DatasetIbsCbs,
+  DiferencaDeDatasets,
+  DiferencaDeTabela,
+  ExcecaoDePrefixo,
+  ExpressoesDoTratamento,
+  Familia,
+  FiltroClassTrib,
+  FiltroDeAtores,
+  FonteDoDataset,
+  GruposClassTrib,
+  GruposCredPres,
+  GruposCst,
+  IdDaFonte,
+  Indicador,
+  IndicadoresDoTratamento,
+  ManifestoDaTabela,
+  ManifestoDoDataset,
+  MudancaDeCampo,
+  MudancaDeRegistro,
+  NomeDaTabela,
+  Nomenclatura,
+  PapelDoAtor,
+  PorTributo,
+  RegistroAliquotaFixa,
+  RegistroAnexo,
+  RegistroAplicabilidade,
+  RegistroAtor,
+  RegistroAtorClassTrib,
+  RegistroClassTrib,
+  RegistroCredPres,
+  RegistroCst,
+  RegistroGrupoDeAtores,
+  RegistroNfseNbs,
+  RegistroReducao,
+  RegistroRedutorCompraGov,
+  RegistroTipoDfe,
+  RegistroTransferenciaCbs,
+  RegistroTratamento,
+  ResultadoAplicabilidade,
+  TabelasDoDataset,
+  TipoDeAliquota,
+  TipoDeMudanca,
+  Tributo,
+  VinculoDfe,
+  VinculoTratamento,
+} from '@sinete/ibs-cbs-dados';
+export {
+  aplicabilidade,
+  carregarDataset,
+  compararDatasets,
+  conferirDataset,
+  DESLOCAMENTO_BRASILIA_MIN,
+  dataCivil,
+  ErroDadosIbsCbs,
+  ehDataIso,
+  exigirDataIso,
+  formatarDiferenca,
+  jsonCanonico,
+  NOMES_DAS_TABELAS,
+  tabelaCanonica,
+  tipoDeMudanca,
+  VERSAO_DO_FORMATO_DOS_DADOS,
+  versaoDoConteudo,
+  vigente,
+} from '@sinete/ibs-cbs-dados';

package/src/index.ts

@@ -0,0 +1,155 @@
+/**
+ * `@sinete/nfe`: NF-e modelo 55 e NFC-e modelo 65. Entrada do domínio (`DadosNfe`), montagem com totais em decimal exato e validação
+ * estrita (`montarNfe`), assinatura por splice (`assinarNfe`) e os serviços da SEFAZ sobre `@sinete/transport`
+ * (`criarClienteNfe`). IBS/CBS pelo motor do sinete por padrão (`calculadoraIbsCbs`), com o dataset carregado sob
+ * demanda. O emissor (bytes gravados antes do envio, trava, retomada, cancelamento com recuperação) está em
+ * `@sinete/emissor/nfe` (ADR 0010).
+ */
+
+export type {
+  ExigenciaRespTec,
+  MontarNfeOpcoes,
+  NfeMontada,
+  ResultadoMontagemNfe,
+} from './build/build.ts';
+export {
+  assinarNfe,
+  assinaturaQrCode,
+  comQrCode,
+  exigenciaRespTec,
+  hashCsrt,
+  montarNfe,
+  NFE_NS,
+  XNOME_HOMOLOGACAO,
+  XPROD_HOMOLOGACAO_NFCE,
+} from './build/build.ts';
+export type { NfceSupl, QrCodeNfceOpcoes } from './build/nfce.ts';
+export { NFCE_LIMITE_SEM_DESTINATARIO, urlsNfce } from './build/nfce.ts';
+export { conferirEmitenteDoCertificado } from './build/rejeicoes.ts';
+export type { Familia } from './build/values.ts';
+export type { DecimalInput, RoundingMode } from './decimal.ts';
+export { Decimal, dec, sum } from './decimal.ts';
+export type { FormatoDecimal } from './format.ts';
+export { formatarDecimal, problemaDeFormato } from './format.ts';
+export type { CodigoOcorrenciaNfe } from './issues.ts';
+export { CODIGOS_OCORRENCIA_NFE } from './issues.ts';
+export type {
+  ClassificacaoIbsCbs,
+  Cobranca,
+  Contingencia,
+  Crt,
+  CstPisCofinsOutras,
+  DadosNfe,
+  Desoneracao,
+  DesoneracaoSt,
+  Destinatario,
+  DetalhePagamento,
+  DocumentoPessoa,
+  Emitente,
+  Endereco,
+  EnderecoExterior,
+  FinNFe,
+  IbsCbsItem,
+  Icms,
+  Icms00,
+  Icms02,
+  Icms10,
+  Icms15,
+  Icms20,
+  Icms30,
+  Icms40,
+  Icms51,
+  Icms53,
+  Icms60,
+  Icms61,
+  Icms70,
+  Icms90,
+  IcmsFcp,
+  IcmsPartilha,
+  IcmsProprio,
+  IcmsRepasseSt,
+  IcmsSn101,
+  IcmsSn102,
+  IcmsSn201,
+  IcmsSn202,
+  IcmsSn500,
+  IcmsSn900,
+  IcmsSt,
+  IcmsStRetido,
+  IcmsUfDest,
+  ImpostoImportacao,
+  ImpostosItem,
+  IndIEDest,
+  InformacoesAdicionais,
+  Ipi,
+  IpiNaoTributado,
+  IpiTributado,
+  Issqn,
+  Item,
+  Local,
+  ModBC,
+  ModBCST,
+  ModFrete,
+  Origem,
+  Pagamento,
+  PisCofins,
+  PisCofinsSt,
+  Produto,
+  ProdutoEspecifico,
+  Referenciada,
+  RefNfp,
+  ResponsavelTecnico,
+  TCIBS_NFe,
+  TMonofasia,
+  Transportador,
+  Transporte,
+  TTribNFe,
+  Volume,
+} from './model.ts';
+export { MotivoDesoneracaoIcms, TipoPagamento } from './model.ts';
+export type { CalculadoraIbsCbs, PedidoIbsCbsItem, PedidoIbsCbsNota, RespostaIbsCbs } from './ports.ts';
+export { rotuloDoCaminho } from './rotulo.ts';
+export type { CalculadoraIbsCbsOpcoes, GrupoIbsCbs } from './rtc.ts';
+export { calculadoraIbsCbs, carregarDatasetEmbarcado, localDaOperacao } from './rtc.ts';
+export type {
+  AutorDocumento,
+  AutorizarOpcoes,
+  Cadastro,
+  CadastroPedido,
+  CancelamentoPedido,
+  CancelamentoSubstituicaoPedido,
+  CartaCorrecaoPedido,
+  ClienteNfe,
+  ClienteNfeOpcoes,
+  ConsultaNfe,
+  ConsultaReciboOpcoes,
+  Distribuicao,
+  DistribuicaoConsulta,
+  DistribuicaoOpcoes,
+  DocumentoDistribuido,
+  EnvioOpcoes,
+  Espera,
+  EventoRegistrado,
+  Inutilizacao,
+  InutilizacaoPedido,
+  ManifestacaoPedido,
+  ManifestacaoTipo,
+  PoliticaRecibo,
+  ProtocoloNfe,
+  ResultadoAutorizacao,
+  ResultadoConsulta,
+  ResultadoEvento,
+  ResultadoInutilizacao,
+  StatusServico,
+  StatusServicoOpcoes,
+} from './services/client.ts';
+export { autorizadorContingencia, criarClienteNfe } from './services/client.ts';
+export { descomprimirGzipBase64 } from './services/gzip.ts';
+export type { DocumentoAssinado } from './services/proc.ts';
+export { documentoAssinado, nfeAssinadaDoProc, recortarElemento } from './services/proc.ts';
+export type { RecuperacaoEvento } from './services/recuperar.ts';
+export { recuperarEventoRegistrado } from './services/recuperar.ts';
+export type { ConteudoDoProtocolo, ResolucaoEnvio } from './services/resolver.ts';
+export { chaveDaDuplicidade, resolverEnvioSemResposta } from './services/resolver.ts';
+export type { Instante } from './time.ts';
+export { deslocamentoDaUf, formatarDh } from './time.ts';

package/src/issues.ts

@@ -0,0 +1,80 @@
+/**
+ * Coletor de ocorrências de validação (`Ocorrencia` do core). O builder junta todas as ocorrências antes de
+ * decidir, em vez de parar na primeira. Os códigos são API pública (snake_case, português, sem acento) e estão listados
+ * em `CODIGOS_OCORRENCIA_NFE`.
+ */
+
+import type { Ocorrencia, OrigemOcorrencia } from '@sinete/core';
+
+export const CODIGOS_OCORRENCIA_NFE = [
+  'campo_obrigatorio',
+  'campo_invalido',
+  'campo_fora_do_pl',
+  'decimal_invalido',
+  'valor_divergente',
+  'combinacao_invalida',
+  'modelo_nao_suportado',
+  'serie_invalida',
+  'documento_invalido',
+  'ie_invalida',
+  'chave_invalida',
+  'referencia_vedada',
+  'resp_tec_obrigatorio',
+  'csrt_obrigatorio',
+  'ibscbs_calculo',
+  'ibscbs_base_ausente',
+  'ibscbs_nao_suportado',
+  'ibscbs_redutor_divergente',
+  'ibscbs_regra_nt',
+  'totais_divergentes',
+  'itens_limite',
+  'contingencia_invalida',
+  'pagamento_igual_total',
+  'emitente_difere_do_certificado',
+  'grupo_vedado',
+  'pagamento_invalido',
+  'qrcode_invalido',
+  'schema',
+] as const;
+
+export type CodigoOcorrenciaNfe = (typeof CODIGOS_OCORRENCIA_NFE)[number];
+
+export class Issues {
+  readonly list: Ocorrencia[];
+
+  constructor() {
+    this.list = [];
+  }
+
+  /** Ocorrência sobre a entrada, a não ser que `origem` diga outra coisa (ADR 0011). */
+  add(path: string, code: CodigoOcorrenciaNfe | string, message: string, origem: OrigemOcorrencia = 'entrada'): void {
+    this.list.push({ caminho: path, code, mensagem: message, origem });
+  }
+
+  /** Ocorrência sobre o que o sinete montou a partir da entrada (XML, schema, PL, chave gerada, calculadora). */
+  montagem(path: string, code: CodigoOcorrenciaNfe | string, message: string): void {
+    this.add(path, code, message, 'montagem');
+  }
+
+  /** As ocorrências com a `origem` preenchida: a que veio sem (a de um validador avulso) é da entrada. */
+  get classificadas(): readonly Ocorrencia[] {
+    return this.list.map((i) => (i.origem === undefined ? { ...i, origem: 'entrada' } : i));
+  }
+
+  /** Junta ocorrências de outra fonte; a que vier sem `origem` recebe a informada. */
+  addAll(issues: readonly Ocorrencia[], origem: OrigemOcorrencia = 'entrada'): void {
+    this.list.push(...issues.map((i) => (i.origem === undefined ? { ...i, origem } : i)));
+  }
+
+  /** Troca a `origem` das ocorrências a partir da posição `inicio` (as que uma conferência acabou de acrescentar). */
+  reclassificarDesde(inicio: number, origem: OrigemOcorrencia): void {
+    for (let k = inicio; k < this.list.length; k++) {
+      const i = this.list[k];
+      if (i !== undefined) this.list[k] = { ...i, origem };
+    }
+  }
+
+  get empty(): boolean {
+    return this.list.length === 0;
+  }
+}