@sinete/nfe 0.1.0 → 0.2.0

package/src/format.ts

@@ -5,60 +5,61 @@
 
 import type { Decimal, RoundingMode } from './decimal.ts';
 
-export interface DecimalFormat {
+export interface FormatoDecimal {
   /** Nome curto, para mensagens. */
-  readonly name: string;
+  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 minBelowOne?: number;
+  readonly minimoAbaixoDeUm?: number;
   /** O pattern recusa zero (`TDec_1302Opc`, `TDec_0302a04Opc`): o campo zerado deve ser omitido. */
-  readonly nonZero?: boolean;
+  readonly naoNulo?: boolean;
   /** Maior quantidade de dígitos inteiros aceita. */
-  readonly intDigits: number;
+  readonly digitosInteiros: number;
 }
 
 /** `TDec_1302`, `TDec1302RTC`: 13 inteiros e exatamente 2 casas. */
-export const D1302: DecimalFormat = { name: 'TDec_1302', min: 2, max: 2, intDigits: 13 };
+export const D1302: FormatoDecimal = { nome: 'TDec_1302', min: 2, max: 2, digitosInteiros: 13 };
 /** `TDec_1302Opc`: como `TDec_1302`, sem zero. */
-export const D1302_OPC: DecimalFormat = { name: 'TDec_1302Opc', min: 2, max: 2, intDigits: 13, nonZero: true };
+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: DecimalFormat = { name: 'TDec_0302a04', min: 2, max: 4, intDigits: 3 };
+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: DecimalFormat = { name: 'TDec_0302a04Opc', min: 2, max: 4, intDigits: 3 };
+export const D0302A04_OPC: FormatoDecimal = { nome: 'TDec_0302a04Opc', min: 2, max: 4, digitosInteiros: 3 };
 /** `TDec_0302Max100`: 2 casas exatas. */
-export const D0302: DecimalFormat = { name: 'TDec_0302Max100', min: 2, max: 2, intDigits: 3 };
+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: DecimalFormat = { name: 'TDec_1104v', min: 0, max: 4, intDigits: 11 };
+export const D1104V: FormatoDecimal = { nome: 'TDec_1104v', min: 0, max: 4, digitosInteiros: 11 };
 /** `TDec_1104`, `TDec1104RTC`: 11 inteiros e 4 casas. */
-export const D1104: DecimalFormat = { name: 'TDec_1104', min: 4, max: 4, intDigits: 11 };
+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: DecimalFormat = { name: 'TDec_1110v', min: 0, max: 10, intDigits: 11 };
+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: DecimalFormat = { name: 'TDec_1204v', min: 0, max: 4, intDigits: 12 };
+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: DecimalFormat = { name: 'TDec_1204', min: 4, max: 4, intDigits: 12 };
+export const D1204: FormatoDecimal = { nome: 'TDec_1204', min: 4, max: 4, digitosInteiros: 12 };
 /** `TDec_1203`: 12 inteiros e 3 casas. */
-export const D1203: DecimalFormat = { name: 'TDec_1203', min: 3, max: 3, intDigits: 12 };
+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: DecimalFormat = { name: 'TDec_0803v', min: 0, max: 3, intDigits: 8, minBelowOne: 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 formatDecimal(value: Decimal, format: DecimalFormat, mode: RoundingMode = 'HALF_UP'): string {
-  const r = value.round(format.max, mode);
-  let places = Math.max(format.min, Math.min(format.max, r.significantScale()));
-  if (format.minBelowOne !== undefined && !r.isZero() && r.abs().lt(1)) places = Math.max(places, format.minBelowOne);
-  return r.toFixed(places, mode);
+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 formatProblem(value: Decimal, format: DecimalFormat): string | undefined {
-  if (value.isNegative()) return 'valor negativo';
-  if (format.nonZero && value.isZero()) return 'valor zero não é aceito neste campo';
-  if (value.significantScale() > format.max) return `mais de ${format.max} casas decimais`;
-  const intDigits = value.round(0, 'DOWN').abs().toString().replace(/^0$/, '').length;
-  if (intDigits > format.intDigits) return `mais de ${format.intDigits} dígitos inteiros`;
+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

@@ -3,87 +3,87 @@
  * `@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`: `loadDataset`, `verifyDataset`, diff, tipos). O dataset
+ * 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`, `IsoDate` e `Validity` vêm do motor (os de `Dec` e `IsoDate` são os
- * mesmos; a `Validity` dos dados, com os campos do dataset, fica acessível pelos tipos que a usam).
+ * `@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 {
-  ActorClassTribRecord,
-  ActorFilter,
-  ActorGroupRecord,
-  ActorRecord,
-  ActorRole,
-  AnnexRecord,
-  Applicability,
-  ApplicabilityRecord,
-  ApplicabilityResult,
-  ByTributo,
-  CbsTransferRecord,
-  ChangeKind,
-  ClassTribCredit,
-  ClassTribFilter,
-  ClassTribGroups,
-  ClassTribLegal,
-  ClassTribRecord,
-  CredPresCalculation,
-  CredPresGroups,
-  CredPresInForce,
-  CredPresRates,
-  CredPresRecord,
-  CstGroups,
-  CstRecord,
-  DataSource,
-  DatasetBundle,
-  DatasetDiff,
-  DatasetManifest,
-  DatasetTables,
-  DfeLink,
-  DfeTypeRecord,
-  Family,
-  FieldChange,
-  FixedRateRecord,
-  GovPurchaseReducerRecord,
-  IbsCbsDataErrorCode,
-  IbsCbsDataset,
-  Indicator,
-  LegalBasis,
-  NfseNbsRecord,
-  Nomenclature,
-  PrefixException,
-  RateKind,
-  RecordChange,
-  ReductionRecord,
-  SourceId,
-  TableDiff,
-  TableManifest,
-  TableName,
-  TaxContent,
-  TreatmentExpressions,
-  TreatmentFlags,
-  TreatmentLink,
-  TreatmentRecord,
+  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 {
-  applicability,
-  BRASILIA_OFFSET_MINUTES,
-  canonicalJson,
-  canonicalTable,
-  changeKind,
-  civilDate,
-  contentVersionOf,
-  DATA_SCHEMA_VERSION,
-  diffDatasets,
-  formatDiff,
-  IbsCbsDataError,
-  inForce,
-  isIsoDate,
-  loadDataset,
-  requireIsoDate,
-  TABLE_NAMES,
-  verifyDataset,
+  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

@@ -1,25 +1,25 @@
 /**
- * `@sinete/nfe`: NF-e modelo 55 e NFC-e modelo 65. Entrada do domínio (`NfeInput`), montagem com totais em decimal exato e validação
- * estrita (`buildNfe`), assinatura por splice (`signNfe`) e os serviços da SEFAZ sobre `@sinete/transport`
- * (`createNfeClient`). IBS/CBS pelo motor do sinete por padrão (`ibsCbsCalculator`), com o dataset carregado sob
+ * `@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 {
-  BuildNfeOptions,
-  BuildNfeResult,
-  BuiltNfe,
   ExigenciaRespTec,
+  MontarNfeOpcoes,
+  NfeMontada,
+  ResultadoMontagemNfe,
 } from './build/build.ts';
 export {
+  assinarNfe,
   assinaturaQrCode,
-  buildNfe,
   comQrCode,
   exigenciaRespTec,
   hashCsrt,
+  montarNfe,
   NFE_NS,
-  signNfe,
   XNOME_HOMOLOGACAO,
   XPROD_HOMOLOGACAO_NFCE,
 } from './build/build.ts';
@@ -29,16 +29,17 @@ 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 { DecimalFormat } from './format.ts';
-export { formatDecimal, formatProblem } from './format.ts';
-export type { NfeIssueCode } from './issues.ts';
-export { NFE_ISSUE_CODES } from './issues.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,
@@ -89,7 +90,6 @@ export type {
   ModBC,
   ModBCST,
   ModFrete,
-  NfeInput,
   Origem,
   Pagamento,
   PisCofins,
@@ -107,47 +107,49 @@ export type {
   Volume,
 } from './model.ts';
 export { MotivoDesoneracaoIcms, TipoPagamento } from './model.ts';
-export type { IbsCbsCalculator, IbsCbsItemRequest, IbsCbsNotaRequest, IbsCbsResponse } from './ports.ts';
+export type { CalculadoraIbsCbs, PedidoIbsCbsItem, PedidoIbsCbsNota, RespostaIbsCbs } from './ports.ts';
 export { rotuloDoCaminho } from './rotulo.ts';
-export type { GrupoIbsCbs, IbsCbsCalculatorOptions } from './rtc.ts';
-export { carregarDatasetEmbarcado, ibsCbsCalculator, localDaOperacao } from './rtc.ts';
+export type { CalculadoraIbsCbsOpcoes, GrupoIbsCbs } from './rtc.ts';
+export { calculadoraIbsCbs, carregarDatasetEmbarcado, localDaOperacao } from './rtc.ts';
 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 './services/client.ts';
-export { autorizadorContingencia, createNfeClient } from './services/client.ts';
-export { gunzipBase64 } from './services/gzip.ts';
+export { autorizadorContingencia, criarClienteNfe } from './services/client.ts';
+export { descomprimirGzipBase64 } from './services/gzip.ts';
 export type { DocumentoAssinado } from './services/proc.ts';
-export { documentoAssinado, nfeAssinadaDoProc, sliceElement } 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 { formatDh, offsetDaUf } from './time.ts';
+export { deslocamentoDaUf, formatarDh } from './time.ts';

package/src/issues.ts

@@ -1,12 +1,12 @@
 /**
- * Coletor de ocorrências de validação (`ValidationIssue` do core). O builder junta todas as ocorrências antes de
+ * 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 `NFE_ISSUE_CODES`.
+ * em `CODIGOS_OCORRENCIA_NFE`.
  */
 
-import type { OrigemOcorrencia, ValidationIssue } from '@sinete/core';
+import type { Ocorrencia, OrigemOcorrencia } from '@sinete/core';
 
-export const NFE_ISSUE_CODES = [
+export const CODIGOS_OCORRENCIA_NFE = [
   'campo_obrigatorio',
   'campo_invalido',
   'campo_fora_do_pl',
@@ -37,32 +37,32 @@ export const NFE_ISSUE_CODES = [
   'schema',
 ] as const;
 
-export type NfeIssueCode = (typeof NFE_ISSUE_CODES)[number];
+export type CodigoOcorrenciaNfe = (typeof CODIGOS_OCORRENCIA_NFE)[number];
 
 export class Issues {
-  readonly list: ValidationIssue[];
+  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: NfeIssueCode | string, message: string, origem: OrigemOcorrencia = 'entrada'): void {
-    this.list.push({ path, code, message, origem });
+  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: NfeIssueCode | string, message: string): void {
+  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 ValidationIssue[] {
+  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 ValidationIssue[], origem: OrigemOcorrencia = 'entrada'): void {
+  addAll(issues: readonly Ocorrencia[], origem: OrigemOcorrencia = 'entrada'): void {
     this.list.push(...issues.map((i) => (i.origem === undefined ? { ...i, origem } : i)));
   }
 

package/src/model.ts

@@ -1,5 +1,5 @@
 /**
- * Modelo de entrada da NF-e: o que quem emite descreve. O builder (`buildNfe`) transforma isto no objeto tipado do
+ * Modelo de entrada da NF-e: o que quem emite descreve. O builder (`montarNfe`) transforma isto no objeto tipado do
  * `@sinete/schemas` do pacote de liberação vigente, calcula os valores derivados e os totais em decimal exato e
  * confere as regras antes de qualquer serialização.
  *
@@ -727,7 +727,7 @@ export type PisCofinsSt = {
 // ---------------------------------------------------------------------------------------------------------------
 
 /**
- * Classificação do item para IBS/CBS (NT 2025.002): o que o `IbsCbsCalculator` recebe. `CST` e `cClassTrib` vêm do
+ * Classificação do item para IBS/CBS (NT 2025.002): o que o `CalculadoraIbsCbs` recebe. `CST` e `cClassTrib` vêm do
  * cadastro do item (tabela de classificação tributária); o cálculo, as alíquotas e as reduções são da calculadora.
  */
 export interface ClassificacaoIbsCbs {
@@ -955,7 +955,7 @@ export type FinNFe = '1' | '2' | '3' | '4' | '5' | '6';
  */
 export interface Contingencia {
   /**
-   * 6 SVC-AN, 7 SVC-RS; 2 FS-IA; 4 EPEC; 5 FS-DA; 9 off-line, só NFC-e. Para SVC, `tpEmisSvc` do `NfeClient` escolhe pelo
+   * 6 SVC-AN, 7 SVC-RS; 2 FS-IA; 4 EPEC; 5 FS-DA; 9 off-line, só NFC-e. Para SVC, `tpEmisSvc` do `ClienteNfe` escolhe pelo
    * dado da UF.
    */
   readonly tpEmis: '2' | '4' | '5' | '6' | '7' | '9';
@@ -966,7 +966,7 @@ export interface Contingencia {
 }
 
 /** Entrada completa de uma NF-e. */
-export interface NfeInput {
+export interface DadosNfe {
   /**
    * 55 (NF-e, padrão) ou 65 (NFC-e). Na NFC-e mudam os padrões (`indPres` 1, `indFinal` 1, `tpImp` 4), o destinatário
    * fica opcional, o pagamento passa a ser obrigatório e a montagem acrescenta o `infNFeSupl` (QR Code).

package/src/ports.ts

@@ -1,16 +1,16 @@
 /**
  * Portas do `@sinete/nfe` para o que pode vir de fora. A montagem só conhece o contrato estreito declarado aqui; a
- * implementação padrão do IBS/CBS é o `ibsCbsCalculator` (`rtc.ts`, sobre o `@sinete/ibs-cbs`), e quem calcula em outro
- * lugar (ou testa com alíquotas fixas) injeta a sua em `BuildNfeOptions.ibsCbs`.
+ * implementação padrão do IBS/CBS é o `calculadoraIbsCbs` (`rtc.ts`, sobre o `@sinete/ibs-cbs`), e quem calcula em outro
+ * lugar (ou testa com alíquotas fixas) injeta a sua em `MontarNfeOpcoes.ibsCbs`.
  */
 
-import type { Ambiente, Uf, ValidationIssue } from '@sinete/core';
+import type { Ambiente, Ocorrencia, Uf } from '@sinete/core';
 import type { TTribNFe } from '@sinete/schemas/nfe/PL_010f';
 import type { Decimal } from './decimal.ts';
 import type { Instante } from './time.ts';
 
 /** Um item classificado, com os valores que a calculadora pode precisar para a base do IBS/CBS. */
-export interface IbsCbsItemRequest {
+export interface PedidoIbsCbsItem {
   /** Número do item na nota (1 a 990). */
   readonly nItem: number;
   /** CST do IBS/CBS (3 dígitos). */
@@ -54,8 +54,8 @@ export interface IbsCbsItemRequest {
 }
 
 /** Dados da nota que decidem a regra aplicável (local da operação, vigência, compra governamental). */
-export interface IbsCbsNotaRequest {
-  /** Instante do fato gerador (relógio `fatoGerador` do `TimeContext`): decide a vigência das alíquotas. */
+export interface PedidoIbsCbsNota {
+  /** Instante do fato gerador (relógio `fatoGerador` do `ContextoDeTempo`): decide a vigência das alíquotas. */
   readonly fatoGerador: Instante;
   /** Instante da emissão (o do `dhEmi`): decide quais regras de validação da NT já estão implantadas no ambiente. */
   readonly emissao: Instante;
@@ -75,22 +75,22 @@ export interface IbsCbsNotaRequest {
 }
 
 /** Resultado da calculadora: o grupo `IBSCBS` de cada item pedido, já na forma lexical do leiaute. */
-export interface IbsCbsResponse {
+export interface RespostaIbsCbs {
   readonly itens: readonly { readonly nItem: number; readonly IBSCBS: TTribNFe }[];
   /**
-   * Problemas de classificação ou de dado (`path` relativo ao item, como `itens[2].impostos.ibsCbs`). A ocorrência sem
+   * Problemas de classificação ou de dado (`caminho` relativo ao item, como `itens[2].impostos.ibsCbs`). A ocorrência sem
    * `origem` entra como `montagem` (ADR 0011); marque `entrada` a que aponta um valor da nota.
    */
-  readonly issues?: readonly ValidationIssue[];
+  readonly ocorrencias?: readonly Ocorrencia[];
 }
 
 /**
- * Calcula o IBS e a CBS dos itens classificados. O padrão é o `ibsCbsCalculator`, sobre o `@sinete/ibs-cbs/calcular`; nos
+ * Calcula o IBS e a CBS dos itens classificados. O padrão é o `calculadoraIbsCbs`, sobre o `@sinete/ibs-cbs/calcular`; nos
  * testes, um dublê com alíquotas fixas. A calculadora não vê o XML nem o resto da nota além do que está no pedido.
  */
-export interface IbsCbsCalculator {
-  calcular(request: {
-    readonly nota: IbsCbsNotaRequest;
-    readonly itens: readonly IbsCbsItemRequest[];
-  }): IbsCbsResponse | Promise<IbsCbsResponse>;
+export interface CalculadoraIbsCbs {
+  calcular(pedido: {
+    readonly nota: PedidoIbsCbsNota;
+    readonly itens: readonly PedidoIbsCbsItem[];
+  }): RespostaIbsCbs | Promise<RespostaIbsCbs>;
 }

package/src/rotulo.ts

@@ -1,6 +1,6 @@
 /**
  * Rótulo em português do caminho de uma ocorrência da NF-e (ADR 0011), para mostrar a quem preencheu a nota: `Item 2,
- * Descrição do produto` em vez de `itens[1].produto.xProd`. Aceita os caminhos da entrada (`NfeInput`) e os do
+ * Descrição do produto` em vez de `itens[1].produto.xProd`. Aceita os caminhos da entrada (`DadosNfe`) e os do
  * documento montado, tanto os das conferências do montador (`infNFe.det[1].prod.xProd`) quanto os do validador de XSD
  * (`/infNFe/det[2]/prod/xProd`).
  */
@@ -15,7 +15,7 @@ const item =
 
 /** Do mais específico ao mais geral. Os índices chegam somados de um. */
 const GRUPOS: readonly GrupoDeCaminho[] = [
-  // Entrada (NfeInput)
+  // Entrada (DadosNfe)
   { padrao: /^emitente\b/, rotulo: 'Emitente' },
   { padrao: /^destinatario\b/, rotulo: 'Destinatário' },
   { padrao: /^retirada\b/, rotulo: 'Local de retirada' },
@@ -132,6 +132,6 @@ const rotular = criarRotuloDoCaminho({ grupos: GRUPOS, campos: CAMPOS, padrao: '
  * Rótulo em português do caminho de uma ocorrência da NF-e: `Grupo, Campo` quando os dois são conhecidos (`Emitente,
  * Inscrição estadual`), só um deles quando falta o outro, e `Dados da NF-e` quando nenhum é.
  */
-export function rotuloDoCaminho(path: string): string {
-  return rotular(path);
+export function rotuloDoCaminho(caminho: string): string {
+  return rotular(caminho);
 }