sgp-sdk 1.1.3 → 2.0.0-beta.1

package/README.md

@@ -1,262 +1,461 @@
 # sgp-sdk
 
-Unofficial TypeScript client for the HTTP API of SGP, the ISP ERP by TSMX. Not affiliated with
-TSMX. It is a _dumb_ SDK: typed inputs and outputs, normalized errors, no business rules. Your
-application decides what to do with the data.
+Cliente TypeScript não oficial para a API HTTP do SGP, o ERP de provedores de internet da TSMX.
+Sem vínculo com a TSMX.
 
-- Reads, plus writes on `crm`, `ura.openTicket` and `suporte.addCustomerDocument` (see
-  [Writes](#writes)).
-- ESM package with types, Node >= 22 (also runs on Bun). The only runtime dependency is `zod`.
-- Methods never throw for network, HTTP or schema failures; they return a result object.
+> **Versão 2.0.** Esta documentação descreve a 2.0 (em preparação, ainda não publicada). A série
+> 1.x está congelada e depreciada: não recebe mais mudanças. Para migrar, leia
+> [MIGRATION.md](MIGRATION.md).
 
-## Install
+## O que é e o que não é
+
+O sgp-sdk é um **gateway de integração**: encapsula o transporte e a semântica conhecida de cada
+operação do SGP, preserva todos os dados que recebe, devolve falhas com códigos estáveis e diz
+explicitamente o que sabe, e o que não sabe, sobre o efeito de uma escrita.
+
+Ele **não é** uma camada de política. Quem decide autorização, orquestração de vários passos,
+recuperação e o que chega a um usuário ou a um agente é a sua aplicação. O SDK também não
+renomeia campos (`cpfcnpj`, `planobase_id` e os demais chegam e saem com os nomes do SGP) e não
+inventa valores: ausente, `null` e `""` chegam como o SGP mandou.
+
+- **Somente servidor.** O cliente carrega o token do SGP; navegadores não são suportados.
+- **ESM**, Node >= 22 e Bun. A única dependência de runtime é `zod`. Os testes unitários rodam no
+  Bun; o Node é coberto pelo teste de fumaça do pacote construído.
+- Nenhum método lança exceção por falha esperada (input inválido, rede, timeout, cancelamento,
+  recusa do SGP, resposta incompatível): tudo volta no resultado. Só `createSgpClient` lança, para
+  configuração inválida (`InvalidConfigurationError`), além de bugs internos.
+- Tudo fora de `experimental.*` segue SemVer.
+
+Instância de SGP: a versão do SGP em que cada operação foi comprovada é **desconhecida**. O que foi
+provado, onde e quando está em [COMPATIBILITY.md](COMPATIBILITY.md).
+
+## Instalação
 
 ```sh
 bun add sgp-sdk
-# or
+# ou
 npm install sgp-sdk
 ```
 
-Types resolve under `"moduleResolution": "bundler"` (Bun, Next.js, tsx, Vite, esbuild) and under
-`node16` / `nodenext`: the emitted `.d.ts` files carry explicit `.js` extensions.
+Os tipos resolvem com `moduleResolution` `bundler` e `node16`/`nodenext`.
 
-## Usage
+## Quickstart
 
 ```ts
-import { clientPersonalKeys, createSgpClient, omitSensitive } from "sgp-sdk";
+import { CONTRACT_STATUS, createSgpClient } from "sgp-sdk";
 
 const sgp = createSgpClient({
-  baseUrl: "https://sgp.example.com",
-  token: "<token of your app>",
-  app: "<app name>",
-  // timeoutMs: 20_000,  // default
-  // fetch: fakeFetch,   // default: the global fetch (inject a fake in tests)
+  baseUrl: "https://sgp.example.com", // origem da instância, sem caminho
+  credentials: { kind: "token", token: "<token>", app: "<nome do app>" }, // carregue como preferir
 });
 
-const plans = await sgp.ura.listPlans();
-if (plans.success) {
+// Uma leitura: `ok` estreita o resultado.
+const plans = await sgp.plans.list();
+if (plans.ok) {
   console.log(plans.data.planos.length, plans.warnings ?? []);
 } else {
-  console.error(plans.error.code, plans.error.status, plans.error.endpoint);
+  console.error(plans.error.code, plans.response?.status);
 }
 
-const clients = await sgp.ura.listClients({ cpfcnpj: "00000000000", limit: 1 });
-if (clients.success) {
-  for (const client of clients.data.clientes) {
-    const safe = omitSensitive(client, clientPersonalKeys); // no name, CPF/CNPJ, address, contacts
-    console.log(safe.id);
-  }
+// Uma escrita: em caso de falha, `error.effect` diz o que fazer.
+const change = await sgp.contracts.updateStatus({ contrato: 1001, status: CONTRACT_STATUS.active });
+if (change.ok) {
+  console.log(change.data.resposta.contrato_status);
+} else if (change.error.effect === "none") {
+  // Nada foi aplicado: corrigir a entrada e chamar de novo não duplica nada.
+  console.error(change.error.code, change.error.reason);
+} else {
+  // "unknown": o SGP pode ter aplicado. Leia o estado (contracts.list) antes de enviar de novo.
 }
 ```
 
-The SDK never reads the environment: load the credentials your way and pass them in.
-
-### Methods
-
-Field names in params and responses are exactly what SGP sends. Each method's JSDoc cites the HTTP
-method and path.
-
-| Method                                                  | SGP route                                               |
-| ------------------------------------------------------- | ------------------------------------------------------- |
-| `ura.listClients(params?)`                              | `POST /api/ura/clientes/`                               |
-| `ura.lookupCustomer(params)`                            | `POST /api/ura/consultacliente/`                        |
-| `ura.listContracts(params?)`                            | `POST /api/ura/listacontrato/`                          |
-| `ura.listServiceOrders(params?)`                        | `POST /api/ura/ordemservico/list/`                      |
-| `ura.listInvoices(params?)`                             | `POST /api/ura/titulos/`                                |
-| `ura.listPops()`                                        | `POST /api/ura/pops/`                                   |
-| `ura.listNas()`                                         | `POST /api/ura/nas/list/`                               |
-| `ura.listPaymentCarriers()`                             | `GET /api/ura/portador/`                                |
-| `ura.checkCoverage(params)`                             | `GET /api/ura/viabilidadeinstalacao`                    |
-| `ura.listPlans()`                                       | `GET /api/ura/consultaplano/`                           |
-| `ura.listOccurrenceMethods()`                           | `GET /api/ura/ocorrencia/metodo/list/`                  |
-| `ura.openTicket(params)`                                | `POST /api/ura/chamado/`                                |
-| `os.listOccurrenceTypes()`                              | `GET /api/os/ocorrencia/tipo/list/`                     |
-| `os.listOccurrenceReasons()`                            | `GET /api/os/ocorrencia/motivo/list/`                   |
-| `precadastro.listDueDays()`                             | `POST /api/precadastro/vencimento/list`                 |
-| `precadastro.listSellers()`                             | `POST /api/precadastro/vendedor/list`                   |
-| `crm.createIndividualCustomer(params)`                  | `POST /api/crm/cliente/F`                               |
-| `crm.createCompanyCustomer(params)`                     | `POST /api/crm/cliente/J`                               |
-| `crm.createContract(clienteId, params)`                 | `POST /api/crm/cliente/{cliente_id}/contratos/`         |
-| `crm.updateCustomerStatus(clienteId, params)`           | `POST /api/crm/cliente/{cliente_id}/status/`            |
-| `suporte.addCustomerDocument(clienteId, file, params?)` | `PUT /api/suporte/cliente/{cliente_id}/documento/add/`  |
-| `suporte.listCustomerDocuments(clienteId)`              | `GET /api/suporte/cliente/{cliente_id}/documento/list/` |
-
-Every route must be allowed on the consumer's token in SGP (System > Tools > Admin Panel >
-Tokens). A route outside the whitelist returns `ROUTE_NOT_ALLOWED`. Paging is the API's own:
-`offset` and `limit`; the SDK never pages for you.
-
-`ura.checkCoverage({ gateway, raio, coordenada })` checks installation viability: the answer is keyed
-by the gateway's name (data-defined, e.g. `SGPMaps`) and holds the CTOs within `raio` meters or the
-message `"Localização inviável"`. The coordinate (`"lat,lng"`) comes from the consumer; the SDK does
-not geocode. `lat`, `lng` and `distancia` are always numbers (Geogrid sends them as numeric strings
-and the SDK converts them). A malformed gateway answer, such as a CTO with a non-numeric `lat`, is
-`SCHEMA_MISMATCH`.
-
-## Result and error contract
-
-Every method returns `SgpResult<T>`:
+O SDK nunca lê o ambiente: as credenciais vêm de você. Exemplos completos e executados no CI, contra
+um `fetch` falso, estão em `examples/` do repositório: `quickstart.ts`,
+`write-with-effect.ts`,
+`sensitive-logging.ts` e `request-raw.ts` (fora do pacote npm).
+Para rodar um deles: `SGP_BASE_URL=... SGP_TOKEN=... SGP_APP=... bun examples/quickstart.ts`.
+
+Cada rota precisa estar liberada no token do SGP, e a barra final conta (as rotas da
+[referência](#referência-de-operações) estão exatamente como o SDK as chama). Rota fora da lista do
+token volta como `FORBIDDEN` com `reason: "TOKEN_ROUTE_NOT_ALLOWED"`.
+
+Nas rotas `GET`, `token` e `app` vão na query string; nas demais, no corpo. Uma camada de `fetch`,
+proxy ou tracing que você injete enxerga isso.
+
+## O modelo de resultado
+
+Toda operação devolve `SgpResult<T>`:
 
 ```ts
 type SgpResult<T> =
-  | { success: true; data: T; warnings?: SchemaWarning[] }
-  | { success: false; error: SgpError };
+  | {
+      ok: true;
+      data: T;
+      response: CapturedResponse;
+      attempts: number;
+      warnings?: SchemaWarning[];
+      diagnostics?: Diagnostic[];
+    }
+  | {
+      ok: false;
+      error: SgpError;
+      response: CapturedResponse | null;
+      attempts: number;
+      diagnostics?: Diagnostic[];
+    };
 
 interface SgpError {
-  status: number; // HTTP status, 0 when no response arrived
-  code: SgpErrorCode;
-  message: string; // written by the SDK, in English
-  detail?: string; // SGP's own error text (`detail`, `msg`, `errors` or `error`), copied verbatim
-  endpoint: string; // path only, never the query string
+  code: SgpErrorCode; // estável: ramifique por ele, nunca por `message`
+  message: string; // escrita pelo SDK, em inglês
+  operation: string; // ex.: "customers.list"
+  reason?: string; // código específico da operação, só com evidência
+  effect?: "none" | "unknown"; // só em escritas
+  sgp?: { detail?: unknown; msg?: unknown; error?: unknown; errors?: unknown }; // campos de erro do SGP, como vieram
+  issues?: readonly string[]; // em INVALID_RESPONSE: caminhos que quebraram o contrato, nunca valores
 }
+```
 
-interface SchemaWarning {
-  path: string; // e.g. "contratos[0].cobIsento"
-  expected: string; // type names only, never values
-  received: string;
-}
+### Códigos
+
+| Código              | Quando                                                                                                                                                                   |
+| ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `INVALID_INPUT`     | Entrada local inválida (campos, chaves desconhecidas, parâmetros de caminho, opções da chamada). Nada é enviado: `attempts: 0`, `response: null`                         |
+| `UNAUTHORIZED`      | HTTP 401, ou 403 cujo `detail` diz que as credenciais estão incorretas                                                                                                   |
+| `FORBIDDEN`         | Demais 403. Com `reason: "TOKEN_ROUTE_NOT_ALLOWED"` quando o `detail` diz que as credenciais "não foram fornecidas" (rota fora da lista do token, ou barra final errada) |
+| `RATE_LIMITED`      | HTTP 429 (nunca observado na instância)                                                                                                                                  |
+| `ROUTE_NOT_ALLOWED` | Restrição local do SDK: hoje só `request()` na rota de anotações (use `experimental.annotations.list`). Nada é enviado; nunca mapeia o 405 do HTTP                       |
+| `NOT_FOUND`         | HTTP 404 (rota ou recurso; o significado específico, só via `reason`)                                                                                                    |
+| `REJECTED`          | Demais 4xx (400, 402, 405, 409, 422...), inclusive validação de campo do SGP, e recusas conhecidas que o SGP devolve com HTTP 200                                        |
+| `UPSTREAM`          | HTTP 5xx                                                                                                                                                                 |
+| `NETWORK`           | Falha de transporte (DNS, conexão, TLS, corpo interrompido)                                                                                                              |
+| `TIMEOUT`           | O prazo do SDK expirou (`timeoutMs`)                                                                                                                                     |
+| `ABORTED`           | O seu `abortSignal` cancelou                                                                                                                                             |
+| `INVALID_RESPONSE`  | 2xx fora do contrato do método, ou status que o método não aceita (3xx: redirecionamentos nunca são seguidos)                                                            |
+
+O status HTTP recebido sempre decide o código; um corpo ilegível não apaga um status já recebido
+(vira `response.body.kind === "unavailable"`).
+
+### `reason`
+
+Código específico de uma operação, **só** onde há evidência por operação; nunca um mapa global de
+status. Os existentes:
+
+| `reason`                      | Operação                                   | Situação                               |
+| ----------------------------- | ------------------------------------------ | -------------------------------------- |
+| `TOKEN_ROUTE_NOT_ALLOWED`     | qualquer (com `FORBIDDEN`)                 | 403 "credenciais não foram fornecidas" |
+| `DOCUMENT_ALREADY_REGISTERED` | `preRegistrations.create`                  | 402, CPF já cadastrado                 |
+| `STATUS_NOT_CHANGED`          | `contracts.updateStatus`                   | 400 "Status de Contrato não alterado." |
+| `CUSTOMER_NOT_IN_CRM`         | `crm.contracts.create`, `.createByCpfCnpj` | 400 "Não encontrado cliente CRM ..."   |
+| `CONTRACT_NOT_ACTIVE`         | `services.addTv`                           | 400, contrato não ativo                |
+
+Sem `reason`, a falha continua útil: `code`, `effect`, `sgp` e `response.body` dizem tudo o que o
+SGP disse.
+
+### `effect`: o que se sabe sobre uma escrita
+
+Só escritas têm `error.effect`; leituras não têm. O código sozinho não determina o efeito (e "leitura"
+é propriedade da operação conhecida, nunca do verbo HTTP).
+
+- **`"none"`**: o SDK consegue afirmar que a mudança pedida **não** foi aplicada. Acontece em recusa
+  local (`INVALID_INPUT`), cancelamento antes do envio, recusa conhecida da operação (tabela de
+  `reason` acima) e 4xx do SGP com formato de erro de campo ou de negócio (`errors` como objeto,
+  `error` ou `detail` como texto). Corrigir a entrada e chamar de novo é seguro.
+- **`"unknown"`**: o SGP pode ter aplicado. Vale para timeout, falha de rede, cancelamento depois do
+  envio, 5xx, 3xx, 2xx fora do contrato, 4xx com corpo ilegível ou de formato não reconhecido, a
+  recusa com HTTP 200 de `occurrences.create` (`status: 0`) e o "invólucro genérico" do SGP
+  (`errors` como **array**, "Ocorreu um erro: ..."), salvo quando a operação o declara como
+  recusa conhecida.
+
+Uma observação de "nada foi aplicado" é registrada como observação com seu método de verificação
+(releitura), não como garantia.
+
+**Diante de `"unknown"`, não reenvie às cegas.** Releia o estado e só então decida:
+
+| Escrita que ficou em `unknown`                               | Leitura que verifica                                                           |
+| ------------------------------------------------------------ | ------------------------------------------------------------------------------ |
+| `crm.customers.create`                                       | `customers.search` ou `customers.list` pelo documento                          |
+| `crm.contracts.create`, `crm.contracts.createByCpfCnpj`      | `crm.contracts.list` (por documento)                                           |
+| `crm.customers.updateStatus`                                 | ler o cliente antes de reenviar                                                |
+| `contracts.updateStatus`, `contracts.update`                 | `contracts.list({ contrato })`                                                 |
+| `preRegistrations.create`                                    | `customers.list({ cpfcnpj })` (a resposta de sucesso não traz ids)             |
+| `occurrences.create`                                         | `workOrders.list({ contrato })`; com `desativa_os: 1` não há OS para consultar |
+| `services.changePlan`, `services.addTv`, `services.removeTv` | `customers.list` (serviços do contrato)                                        |
+| `documents.add`                                              | `documents.list`                                                               |
+
+### `sgp`, `response`, `warnings`, `attempts`
+
+- **`error.sgp`** projeta os campos de erro do SGP (`detail`, `msg`, `error`, `errors`) com os
+  valores como vieram. O corpo inteiro continua em `response.body`.
+- **`response`** é a resposta HTTP bruta: `{ status, headers, body }`, com nomes de header em
+  minúsculas. `body` é um valor discriminado: `{ kind: "json", value }` (o valor pode ser `null`),
+  `{ kind: "text", text }`, `{ kind: "empty" }`, `{ kind: "unavailable", reason }` (o corpo começou e
+  não foi lido até o fim) ou `{ kind: "withheld" }` (veja [leituras com escopo](#leituras-com-escopo)).
+  É o corpo já decodificado, não os bytes. `response` é `null` quando nenhuma resposta HTTP existiu.
+- **`warnings`** aparece quando um campo **secundário** veio com tipo inesperado: o campo sai de
+  `data`, e `{ path, dropped, expected, received }` registra o caminho e os nomes dos tipos (nunca
+  valores). O valor original continua intacto em `response.body`. Os campos **estruturais** de cada
+  operação (ids e o que a navegação precisa) são validados com rigor: se falharem, o resultado é
+  `INVALID_RESPONSE`.
+- **`attempts`** conta as requisições que o SDK iniciou: 0 quando recusou localmente, 1 na primeira.
+- **Fidelidade.** Campos conhecidos são tipados; os desconhecidos chegam em `data` em todos os níveis
+  (raiz, aninhados, arrays), sem serem descartados. Um item que o SDK não consegue interpretar faz a
+  resposta falhar com `INVALID_RESPONSE`; nunca vira `{}` nem `[]`.
+- **Paginação.** `customers.list`, `workOrders.list` e `invoices.list` devolvem **uma página**, com
+  a `paginacao` do SGP como veio (`total` nunca é calculado pelo SDK). Para a próxima página, passe
+  `offset`. Listas sem paginação mantêm o formato do SGP (array ou objeto), sem envelope.
+- **Credenciais nos headers.** Os headers capturados nunca carregam o token nem o app: o valor de
+  qualquer parâmetro `token`/`app` é trocado por `<redacted>`, e o valor exato das credenciais (puro
+  ou codificado) também é trocado quando tem 8 caracteres ou mais. **Corpos não são alterados.**
+
+## Tempo, cancelamento e retry
+
+```ts
+const controller = new AbortController();
+const result = await sgp.customers.list(
+  { limit: 20 },
+  {
+    timeoutMs: 5_000, // prazo desta chamada (padrão do cliente: 20 000 ms)
+    abortSignal: controller.signal,
+    maxRetries: 2, // só leituras
+  },
+);
 ```
 
-| Code                 | When                                                                                                                                                                                 |
-| -------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `UNAUTHORIZED`       | 401/403 with `detail` (or `msg`) `"Credenciais de autenticação incorretas."` (wrong token or app)                                                                                    |
-| `ROUTE_NOT_ALLOWED`  | 401/403 with `detail` (or `msg`) `"As credenciais de autenticação não foram fornecidas."`. The SDK always sends credentials, so this means the route is not on the token's whitelist |
-| `NOT_FOUND`          | 404                                                                                                                                                                                  |
-| `METHOD_NOT_ALLOWED` | 405                                                                                                                                                                                  |
-| `VALIDATION`         | any other 4xx: SGP refused the input                                                                                                                                                 |
-| `SCHEMA_MISMATCH`    | 2xx whose body is not JSON, or whose key fields are missing or have the wrong type (`detail` then lists the failing paths)                                                           |
-| `UPSTREAM`           | 5xx                                                                                                                                                                                  |
-| `TIMEOUT`            | the request exceeded `timeoutMs`                                                                                                                                                     |
-| `NETWORK`            | `fetch` failed before a response (DNS, connection, TLS)                                                                                                                              |
-| `UNKNOWN`            | 401/403 with any other `detail` or `msg`, or a status the rows above do not cover                                                                                                    |
-
-SGP answers errors in four formats: `{"detail": "..."}`, `{"msg": "..."}`, `{"errors": ...}` (an
-array of messages or an object of field messages, on CRM routes) and `{"error": "..."}` (e.g. a 404
-`Cadastro não encontrado` on CRM routes). `error.detail` holds, in this order: a string `detail`
-(even empty), a non-empty `msg`, the text of `errors`, a non-empty `error`.
-
-Guarantees:
-
-- The SDK never puts the token, the app, a URL with query string, a raw response body or the
-  original message of a `fetch` exception in anything it returns (`data`, `warnings`, `error`).
-- `error.detail` is SGP's text copied verbatim: it may echo values from your request (for example
-  a contract ID or a CPF in a `msg`). The SDK adds nothing to it, so treat it like the request
-  itself before logging or showing it.
-- 401/403 are classified by that exact `detail` string, not by status (SGP uses either status for
-  the same message). If SGP rewords those messages the code falls to `UNKNOWN`.
-- No retry, no cache, no logging, no automatic paging.
-- Redirects are never followed, so the token and payload are not re-sent to another host: a 3xx
-  answer is an `UNKNOWN` error carrying its status (`outcome: "unknown"` on a write).
-- Unknown keys are dropped at every level (`strip`): everything that reaches you was declared and
-  classified. Required key fields that fail validation are `SCHEMA_MISMATCH`; any other field with
-  an unexpected type becomes `undefined` and is reported in `warnings`.
-
-## Writes
-
-Write methods (`crm.*`, `ura.openTicket` and `suporte.addCustomerDocument`) return
-`SgpWriteResult<T>`: the same as `SgpResult<T>`, but `error` also carries an `outcome` that says
-whether SGP applied the write.
-
-- `"not_applied"`: SGP refused the request (4xx) or the SDK rejected it before sending it. SGP did
-  not apply the write; fix the input and call again.
-- `"unknown"`: no answer (`TIMEOUT`, `NETWORK`), a 5xx, a 3xx (`UNKNOWN`: redirects are never
-  followed), or a 2xx whose body does not confirm the write (`VALIDATION` with the real HTTP
-  status). The write may have happened: check the state in SGP before repeating it.
-- A 4xx whose body has `errors` as an array (e.g. a 400 with `{"errors": ["Ocorreu um erro: ..."]}`)
-  is SGP's generic exception wrapper: it can fail after applying part of the write, so it is
-  `"unknown"`, even when `detail` or `msg` come with it. The `code` stays `VALIDATION` and the
-  `message` reads "SGP reported an error while processing the write; it may have been applied."
-  401/403/404/405/422 stay `"not_applied"` whatever the body, and so does a 4xx whose `errors` is an
-  object of field messages or that carries only `detail` or `msg`.
-
-After `outcome: "unknown"`, read the state back before repeating the write:
-
-| Write                                                       | Read that verifies it                                                                                                        |
-| ----------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------- |
-| `crm.createIndividualCustomer`, `crm.createCompanyCustomer` | `ura.listClients({ cpfcnpj })`                                                                                               |
-| `crm.createContract`                                        | `ura.lookupCustomer` or `ura.listContracts`                                                                                  |
-| `ura.openTicket`                                            | `ura.listServiceOrders({ contrato })`; a ticket with `desativa_os: 1` opens no service order, so there is nothing to look up |
-| `suporte.addCustomerDocument`                               | `suporte.listCustomerDocuments`                                                                                              |
-| `crm.updateCustomerStatus`                                  | run it again; for status 6 on an existing CRM customer, a 404 `NOT_FOUND` means it was applied (it leaves the CRM)           |
-
-A write only succeeds on a 2xx whose body carries the key fields (for example `cliente_id`). The one
-exception is `suporte.addCustomerDocument`: SGP answers an empty 2xx, which succeeds with
-`data: null`. Success there does not prove the file was stored; verify it with
-`suporte.listCustomerDocuments`. The SDK never retries a write.
-
-Sales flow: create the customer (`crm.createIndividualCustomer` or `crm.createCompanyCustomer`),
-create the contract on it (`crm.createContract(clienteId, params)`), then call
-`crm.updateCustomerStatus(clienteId, { status_id: crmStatus.contratoRealizadoNoSgp })` (status 6).
-Without that last step SGP's screen keeps the customer as a CRM customer and blocks contract status
-changes.
-
-`crm.createContract` sends the installation address nested (`endereco_instalacao`) and also as the
-loose fields (`logradouro`, `numero`, ...), and the billing address only nested
-(`endereco_cobranca`). The loose fields carry the installation address; a billing address that
-differs from the installation one has not been verified live, so check it on SGP before sending
-divergent addresses.
-
-Scheduling an installation goes through `ura.openTicket` with `data_hora_agendamento`
-(`"AAAA-MM-DD HH:MM"`); `os_instalacao` in `crm.createContract` opens the order without a date.
-
-The token whitelist accepts regular expressions and the trailing slash counts: release each path
-exactly as in the table above, so `/api/crm/cliente/F` has no final `/` and
-`/api/crm/cliente/{cliente_id}/status/` has one (the `{cliente_id}` routes need a pattern that
-matches any ID).
-
-## Sensitive fields
-
-SGP responses carry credentials and personal data. The SDK transcribes them (the consumer decides
-what to show) and marks them: each endpoint exports `as const` tuples with the keys of one response
-item.
-
-- `secret`: Central password, PPPoE login and password, Wi-Fi passwords and SSIDs, MACs, links with
-  an embedded token.
-- `personal`: CPF/CNPJ, phone, e-mail, address, birth date, customer name, free text typed by
-  operators.
-
-Tuple names follow the item: `clientSecretKeys` / `clientPersonalKeys`,
-`customerContractSecretKeys` / `customerContractPersonalKeys`, and so on (see the package exports).
-`omitSensitive(item, keys)` returns a shallow copy without those keys and removes them from the
-type, so a leak becomes a compile error:
+- **Um único orçamento de tempo por chamada lógica**: tentativas, esperas e leitura do corpo. Nunca
+  reinicia por tentativa. `timeoutMs` por chamada substitui o padrão do cliente (é padrão, não teto).
+  Deve ser um número positivo, finito, até `MAX_TIMEOUT_MS`.
+- **`TIMEOUT`** é o prazo do SDK; **`ABORTED`** é o seu `abortSignal`. Se o sinal já estiver
+  cancelado quando você chama, nada é enviado (`effect: "none"` numa escrita); cancelado depois do
+  envio, `effect: "unknown"`.
+- **Retry é opt-in** (`maxRetries`, padrão 0 = nenhuma nova tentativa), vale **só para leituras**
+  e só para falhas transitórias: `RATE_LIMITED`, `NETWORK` e `UPSTREAM` com HTTP 502, 503 ou 504.
+  Há espera exponencial com jitter (base de 500 ms, teto de 10 s) e `Retry-After` (segundos ou data
+  HTTP) é respeitado como piso, nunca encurtado; se a espera não cabe no orçamento, a chamada
+  termina com a última falha. `TIMEOUT`, `ABORTED`, `INVALID_*`, `UNAUTHORIZED`, `FORBIDDEN`,
+  `NOT_FOUND` e `REJECTED` nunca são repetidos.
+- **Escritas nunca são repetidas pelo SDK**, e `request()` também não, qualquer que seja
+  `maxRetries`. Conferir o `attempts` mostra quantas requisições partiram.
+
+## Hooks
+
+```ts
+const sgp = createSgpClient({
+  baseUrl,
+  credentials,
+  hooks: {
+    onRequest: (m) => log.debug({ op: m.operation, attempt: m.attempt }),
+    onResponse: (m) => log.info({ op: m.operation, status: m.status, ms: m.durationMs }),
+    onError: (m) => log.warn({ op: m.operation, code: m.code }),
+  },
+});
+```
+
+Opcionais, **síncronos** e só para observabilidade. Recebem metadados: `callId` (liga as tentativas de
+uma chamada), `attempt` (1, 2, ...), `operation`, `method`, `pathTemplate` (omitido quando
+desconhecido, como em `request()`) e, conforme o hook, `status`, `code` e `durationMs`. Nunca
+recebem credenciais, URLs nem corpos. `onResponse` roda por tentativa quando os headers chegam;
+`onError`, por tentativa que falhou.
+
+Um hook que lança (ou devolve uma Promise, que quebra o contrato síncrono) **nunca altera o
+resultado**: uma escrita confirmada continua confirmada. O fato aparece em `diagnostics`
+(`{ hook, occurrence }`), sem o valor lançado.
+
+## Dados sensíveis
+
+Fidelidade significa que os dados do SGP chegam inteiros, e o SGP mistura credenciais (logins e senhas
+de Central e PPPoE, Wi-Fi, MAC, IP) e dados pessoais de clientes nas respostas. **A sua aplicação
+projeta o que sai do processo.**
+
+- **`getSensitivity("customers.search")`** devolve, por operação, as chaves secretas e pessoais da
+  entrada (`input`) e da resposta (`output`). Serve para saber o que remover. Uma chave que não está
+  listada **não é segura**: o SGP acrescenta campos sem aviso.
+- **`pick(origem, allowlist)`** copia só os caminhos nomeados (`"clientes[].contratos[].id"`;
+  `"[].id"` para array na raiz). Chave não nomeada nunca sai. Use para tudo o que vai a logs,
+  ferramentas, MCP ou agentes.
+- **`toSafeLog(result)`** devolve a versão para log de um resultado: `ok`, `attempts`, `diagnostics`,
+  `warnings` (caminhos e nomes de tipo), status HTTP e, do erro, `code`, `message`, `operation`,
+  `reason`, `effect`, `issues` e os **nomes** dos campos do SGP que vieram. Sem `data`, sem `response.body`, sem headers, sem o texto de `error.sgp`
+  (que costuma repetir o que você enviou).
+
+```ts
+logger.info(toSafeLog(result)); // nunca `logger.info(result)`
+const forTheAgent = pick(result.data, ["contratos[].contratoId", "contratos[].clienteId"]);
+```
+
+**Nunca registre o resultado cru.** `console.log(result)`, `structuredClone(result)`, um logger que
+percorre o objeto ou uma cópia feita antes de `toSafeLog` enxergam tudo. E os corpos em `response.body`
+**não são redigidos**: podem repetir credenciais ou dados pessoais que o SGP devolveu, e o texto de
+erro do SGP pode ecoar o que você enviou. Os headers são redigidos; os corpos, não.
+
+Veja `examples/sensitive-logging.ts` no repositório.
+
+## Leituras com escopo
+
+Princípio: leitor tolerante na interpretação, **fronteira estrita** no isolamento. A tolerância à
+evolução do contrato do SGP nunca alarga o que sai de uma operação.
+
+`experimental.annotations.list` (anotações de um cliente e/ou contrato) é o caso: o SGP ignora os
+filtros e responde com anotações de **outros** clientes. O SDK seleciona localmente, sobre a única
+resposta recebida:
+
+- `response.body` é `{ kind: "withheld" }` em qualquer status, `error.sgp` guarda só textos, e nenhum
+  hook recebe o corpo. Cada anotação selecionada traz `raw`, uma cópia profunda do registro como o SGP
+  mandou.
+- Uma anotação cuja identidade (cliente ou contrato) não pode ser decidida, ou que embute identidade
+  de outro cliente em qualquer profundidade, faz a chamada inteira falhar com `INVALID_RESPONSE`
+  (`error.issues` aponta os caminhos, sem valores). Falha fechada, nunca pulo silencioso.
+- `request()` recusa essa rota (`ROUTE_NOT_ALLOWED`), para a fronteira não ser contornada.
+- Não é uma fronteira de autorização: autorize os ids que você passa e rode isso só em processo de
+  servidor confiável. Uma camada de `fetch` ou tracing que você injete enxerga o corpo inteiro **antes**
+  da seleção e não deve capturá-lo.
+- É **experimental** e pode mudar de forma incompatível em uma versão menor. A completude não é
+  garantida: o SDK faz uma requisição, nunca pagina e nunca trunca; a rota não documenta paginação.
+
+## `request()`: chamada bruta
+
+Para uma rota que nenhum método cobre ainda, com a mesma autenticação, prazo, cancelamento e hooks.
+**Ferramenta de desenvolvedor: nunca a exponha como ferramenta de agente nem monte `path` ou `body`
+a partir de entrada não confiável.**
 
 ```ts
-const safe = omitSensitive(client, clientPersonalKeys);
-safe.nome; // type error: `nome` was omitted
+const raw = await sgp.request({ method: "POST", path: "/api/ura/clientes/", body: { limit: 1 } });
 ```
 
-The SDK only marks and offers the helper; deciding when to apply it is the consumer's job. Strip
-before logging, caching or forwarding an item to a model.
-
-## Known limitations
-
-- **Placeholder arrays.** These fields are declared as arrays of empty objects
-  (`z.array(z.object({}))`) because no sample response had content for them. Every element arrives
-  as `{}`, with no warning, and what SGP sends inside is dropped:
-  - `listClients`: `clientes[].contratos` and `clientes[].titulos` (use `lookupCustomer` and the
-    contract methods for those details);
-  - `lookupCustomer`: `contratos[].telefones_cargos`, `contratos[].outros` and
-    `contratos[].anotacoes`;
-  - `listServiceOrders`: `ordens_servicos[].tecnicos_auxiliares` and
-    `ordens_servicos[].classificacoes`;
-  - `listPlans`: `planos[].combo`;
-  - `os.listOccurrenceTypes` and `os.listOccurrenceReasons`: `classificacoes` and `setores` of
-    each item;
-  - `listInvoices`: `acordados` and `cobrados` of `titulos[].acordoPagamento`.
-- **Guessed types.** SGP only sent `null` for four `lookupCustomer` fields, so their types are
-  inferred: `contratos[].contrato_unificado_principal` (number),
-  `contratos[].contrato_unificado_filhos` (array of numbers), `contratos[].endereco_pontoreferencia`
-  (string) and `contratos[].tags[].categoria_id` (number). A wrong guess does not fail the call: the
-  field comes out as `undefined` and is reported in `warnings`.
-- **A bad element drops the whole array.** When one element of an array field has the wrong type,
-  the whole field becomes `undefined`, and the warning names only the failing element. For example,
-  a non-string entry in `clientes[].contatos.telefones` drops the whole `telefones` array and the
-  warning path is `clientes[0].contatos.telefones[1]`.
-- `listContracts` does not transcribe the address fields returned by `exibir_endereco`.
-
-## Pending
-
-What is left:
-
-- **E-signature of the adhesion term.** Not available in the SGP API.
-- **Boleto delivery methods and invoice (nota fiscal) fields** of the contract. Not available in the
-  SGP API, so `crm.createContract` leaves them empty.
+- Só caminho relativo sob `/api/` da instância configurada, já na forma final (sem query, `//`,
+  `.`/`..`, `%`). Qualquer outro: `INVALID_INPUT`, `effect: "none"`, `attempts: 0`, nada enviado.
+  Parâmetros de um `GET` vão em `body` (só primitivos). `encoding`: `json` (padrão) ou `form`.
+- Classifica só por HTTP, com o mesmo mapa de status dos métodos. **`ok: true` significa "o SGP
+  aceitou em nível HTTP" (2xx), não sucesso de negócio**: o SGP responde algumas recusas com 200,
+  então leia `data` (o corpo como veio, tipado `unknown`).
+- Nunca segue redirecionamentos (3xx é `INVALID_RESPONSE`) e nunca repete.
+- Depois do envio, toda falha tem `effect: "unknown"`, inclusive 4xx; o verbo nunca é tomado como
+  prova de que a chamada só lê.
+- Não declara chaves sensíveis: trate `data` e `response` como sensíveis.
+
+Veja `examples/request-raw.ts` no repositório.
+
+## IDs com marca e os dois catálogos de planos
+
+Alguns ids têm tipo "com marca" (apenas em tempo de compilação; em runtime são números):
+
+| Tipo                    | De onde vem                                                                                                 | Para onde vai                                                                                                                    |
+| ----------------------- | ----------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------- |
+| `CustomerId`            | `customers.list` (`clientes[].id`), `customers.search` (`clienteId`), `crm.customers.create` (`cliente_id`) | `cliente_id` de `crm.*`, `documents.*`, `customers.list`, `invoices.list`                                                        |
+| `PlanId`                | `plans.list` (`planos[].id`)                                                                                | `plano` de `contracts.list`, `plano_id` de `services.changePlan` e de `crm.contracts.create`, `planobase_id` de `services.addTv` |
+| `PreRegistrationPlanId` | `preRegistrations.listPlans` (`id`)                                                                         | `plano_id` de `preRegistrations.create`                                                                                          |
+
+Um cliente CRM tem o mesmo `CustomerId` do cliente. **O id de um contrato não é um `CustomerId`**, e
+o compilador recusa um no lugar do outro e um número solto onde um id é esperado. Para marcar um
+número em que você confia: `as CustomerId`.
+
+**Há dois catálogos de planos, com espaços de ids diferentes**: o mesmo plano comercial pode ter outro
+id no catálogo do pré-cadastro, e um id aceito por uma rota pode ser recusado pela outra. Os tipos
+`PlanId` e `PreRegistrationPlanId` são mantidos separados de propósito, nos dois sentidos. A
+conversão entre catálogos não é feita pelo SDK.
+
+## Constantes
+
+Códigos fixos do SGP exportados como constantes; as operações aceitam qualquer número e o SGP
+decide.
+
+| Constante          | Valores                                                                                                            | Evidência                                                                                                                                       |
+| ------------------ | ------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------- |
+| `CONTRACT_STATUS`  | `active` 1, `inactive` 2, `canceled` 3, `suspended` 4, `technicalInfeasibility` 5, `new` 6, `activeReducedSpeed` 7 | 1 e 4 confirmados (200 e releitura); 2 enviado e recusado a partir de Ativo; 3, 5 e 7 do painel; 6 documentado pelo fornecedor, nunca observado |
+| `BILLING_METHOD`   | `boleto` 1, `automaticDebit` 2, `booklet` 3, `recurringCharge` 4, `pix` 6                                          | códigos globais fixos; o 5 não é listado (documentado para uma rota, nunca confirmado)                                                          |
+| `ACQUISITION_MODE` | `owned` 0, `loan` 1                                                                                                | o valor 2, que a documentação do fornecedor lista para o CRM, foi recusado ao vivo                                                              |
+| `SERVICE_TYPE`     | `internet` 1                                                                                                       | só o 1 foi enviado ao SGP                                                                                                                       |
+| `CRM_STATUS`       | `underAnalysis` 1 ... `technicalFeasibilityAnalysis` 10                                                            | só o 6 (`contractMadeInSgp`) foi enviado ao vivo                                                                                                |
+
+O SDK não guarda tabela de transições de status: quem decide o que é permitido é o SGP.
+
+## Referência de operações
+
+Cada método aceita `options?: CallOptions` (`abortSignal`, `timeoutMs`, `maxRetries`) como último
+argumento. Campos de entrada e de resposta usam os nomes do SGP. Uma entrada com chave desconhecida é
+recusada localmente (`INVALID_INPUT`); para campos que ainda não têm tipo, use `request()`. O JSDoc de
+cada método, no tipo `SgpClient` (nos tipos publicados, `dist/client.d.ts`), é o texto de referência; aqui
+ficam só rota, codificação, natureza, recusas conhecidas e evidência.
+
+Legenda. **Natureza:** _leitura_ é repetível com `maxRetries`; _escrita_ nunca é repetida.
+**Codificação:** `query` (GET, parâmetros na URL), `json`, `form` (multipart sem arquivos),
+`form-files` (multipart com arquivo). **Evidência**, resumida (detalhes por cenário em
+[COMPATIBILITY.md](COMPATIBILITY.md)): _observado_ (resposta real capturada), _parcial_ (sucesso
+observado, mas recusas só documentadas ou reconstruídas, ou o inverso), _documentado_ (só a
+documentação do fornecedor), _reconstruído_ (corpo reconstruído a partir de relatos ou testes, sem
+captura bruta).
+
+### `customers`
+
+| Método                    | Rota e codificação                      | Natureza | Notas                                                                                                                                                                                                                                 | Evidência                        |
+| ------------------------- | --------------------------------------- | -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------- |
+| `customers.list(input?)`  | `POST /api/ura/clientes/` · json        | leitura  | Uma página; `paginacao` do SGP como veio; filtros `cliente_id`, `cpfcnpj`, `cliente_nome`; contratos e serviços aninhados chegam inteiros                                                                                             | observado                        |
+| `customers.search(input)` | `POST /api/ura/consultacliente/` · json | leitura  | Devolve **candidatos** e nunca escolhe um; ao menos um critério (`cpfcnpj`, `contrato`, `nome`, `login`, `telefone`); texto vazio é recusado; sem resultado é sucesso com `contratos: []`; cada candidato traz credenciais do serviço | observado (corpo mascarado, 1.x) |
+
+### `crm.customers` e `crm.contracts`
+
+| Método                                 | Rota e codificação                                     | Natureza | Notas                                                                                                                                                                                                                                   | Evidência                                         |
+| -------------------------------------- | ------------------------------------------------------ | -------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------- |
+| `crm.customers.create(input)`          | `POST /api/crm/cliente/{F\|J}` · json                  | escrita  | `personType` escolhe a rota; `endereco` aninhado, como o SGP o lê. **Aceita CPF já cadastrado e cria OUTRO cliente com o mesmo documento**: confira antes (`customers.search`). 400 de validação de campo: `REJECTED`, `effect: "none"` | observado (`/F`); `/J` documentado                |
+| `crm.customers.updateStatus(input)`    | `POST /api/crm/cliente/{cliente_id}/status/` · json    | escrita  | Códigos em `CRM_STATUS`. Cliente que já saiu do CRM (ou status 6 repetido): 404 `{error:"Cadastro não encontrado"}`, `NOT_FOUND`, `effect: "none"`                                                                                      | observado (status 6; o 404 vem de captura da 1.x) |
+| `crm.contracts.create(input)`          | `POST /api/crm/cliente/{cliente_id}/contratos/` · json | escrita  | Só para cliente ainda no funil CRM. Recusa `CUSTOMER_NOT_IN_CRM`, `effect: "none"`. `plano_id` é `PlanId`; `modoaquisicao` é `ACQUISITION_MODE`                                                                                         | parcial                                           |
+| `crm.contracts.createByCpfCnpj(input)` | `POST /api/crm/cliente/contratos/?cpfcnpj=` · json     | escrita  | Documento na **query** do POST. Mesma recusa `CUSTOMER_NOT_IN_CRM`. Com documento duplicado, qual cliente recebe o contrato não foi verificado. **Nenhum sucesso foi observado nesta rota**                                             | parcial (sucesso só documentado)                  |
+| `crm.contracts.list(input)`            | `GET /api/crm/cliente/contratos/?cpfcnpj=` · query     | leitura  | Documento que não é cliente CRM: 400, `REJECTED`, sem `reason`                                                                                                                                                                          | observado                                         |
+
+### `preRegistrations`
+
+| Método                           | Rota e codificação                                          | Natureza | Notas                                                                                                                                                                                                                                                                                                                            | Evidência                                                                       |
+| -------------------------------- | ----------------------------------------------------------- | -------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------- |
+| `preRegistrations.create(input)` | `POST /api/precadastro/{F\|J}` · form                       | escrita  | Endereço em campos soltos no topo da entrada (`logradouro`, `numero`, ...), com os nomes do SGP. Com `precadastro_ativar: 1` vira cliente definitivo; contrato só se plano e cobrança forem suficientes. Sucesso traz só `message`, **sem ids**. CPF existente: 402, `REJECTED`, `DOCUMENT_ALREADY_REGISTERED`, `effect: "none"` | parcial (recusa observada; sucesso `{message}` do fornecedor; `/J` documentado) |
+| `preRegistrations.listPlans()`   | `POST /api/precadastro/plano/list` · form (sem barra final) | leitura  | `PreRegistrationPlanId`: catálogo próprio, não é o de `plans.list`                                                                                                                                                                                                                                                               | observado                                                                       |
+| `preRegistrations.listDueDays()` | `POST /api/precadastro/vencimento/list` · json              | leitura  | `id` é o `vencimento_id` de `create`; `dia` é o dia do mês                                                                                                                                                                                                                                                                       | observado (corpo mascarado, 1.x)                                                |
+| `preRegistrations.listSellers()` | `POST /api/precadastro/vendedor/list` · json                | leitura  | `id` é o `vendedor_id`; nome, CPF e e-mail são dados pessoais                                                                                                                                                                                                                                                                    | observado (corpo mascarado, 1.x)                                                |
+
+### `contracts` e `services`
+
+| Método                          | Rota e codificação                                      | Natureza | Notas                                                                                                                                               | Evidência                                        |
+| ------------------------------- | ------------------------------------------------------- | -------- | --------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------ |
+| `contracts.list(input?)`        | `POST /api/ura/listacontrato/` · json                   | leitura  | Sem paginação; array simples; sem filtro pode vir a base inteira do provedor; `plano` é `PlanId`                                                    | observado (corpo mascarado, 1.x)                 |
+| `contracts.updateStatus(input)` | `POST /api/ura/contrato/status/edit/` · json            | escrita  | Ativar inicia a cobrança. O SGP decide as transições. Recusa `STATUS_NOT_CHANGED` (`effect: "none"`). `motivo` vem de `contracts.listStatusReasons` | parcial (200 observado; a recusa é reconstruída) |
+| `contracts.update(input)`       | `POST /api/ura/contrato/edit/` · json                   | escrita  | Só `forma_cobranca` (`BILLING_METHOD`); devolve `resposta.alterados` como o SGP mandou. Sem recusa conhecida                                        | observado                                        |
+| `contracts.listStatusReasons()` | `POST /api/ura/contrato/status/motivos/` · json         | leitura  | Cada provedor tem a sua lista: leia antes de passar `motivo`                                                                                        | reconstruído                                     |
+| `services.changePlan(input)`    | `POST /api/suporte/service/update/{servico_id}/` · form | escrita  | `action` fixa `change_plano`; `servico_tipo` obrigatório (só `1` exercitado); evento de cobrança. Sucesso traz só `msg`                             | observado                                        |
+| `services.addTv(input)`         | `POST /api/servico/tv` · form                           | escrita  | HTTP 201 com `servico_id`; só contratos ativos: recusa `CONTRACT_NOT_ACTIVE` (`effect: "none"`); `planobase_id` é `PlanId`                          | parcial (201 observado; a recusa é reconstruída) |
+| `services.removeTv(input)`      | `DELETE /api/servico/tv/{servico_id}` · form            | escrita  | O contrato vai num corpo multipart no DELETE, como o SGP espera. Sem recusa conhecida                                                               | observado                                        |
+
+### `plans`, `invoices`, `workOrders`, `occurrences`
+
+| Método                      | Rota e codificação                             | Natureza | Notas                                                                                                                                                                             | Evidência                                                        |
+| --------------------------- | ---------------------------------------------- | -------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------- |
+| `plans.list()`              | `GET /api/ura/consultaplano/` · query          | leitura  | Mantém o formato do SGP (`planos` e totais); `planos[].id` é `PlanId`                                                                                                             | observado                                                        |
+| `invoices.list(input?)`     | `POST /api/ura/titulos/` · json                | leitura  | Uma página; `paginacao.total` ausente é `INVALID_RESPONSE`; máximo de 250 por página é do fornecedor. Traz nome, documento, links de pagamento e PIX                              | parcial (página vazia observada; página populada reconstruída)   |
+| `workOrders.list(input?)`   | `POST /api/ura/ordemservico/list/` · json      | leitura  | Uma página; `ocorrencia` é texto e continua texto                                                                                                                                 | observado                                                        |
+| `workOrders.listReasons()`  | `GET /api/os/ocorrencia/motivo/list/` · query  | leitura  | `id` e `codigo` são distintos; `occurrences.create` usa o `codigo` em `motivoos`                                                                                                  | observado (corpo mascarado, 1.x)                                 |
+| `occurrences.create(input)` | `POST /api/ura/chamado/` · json                | escrita  | "Chamado" do SGP. Devolve `id` da **ocorrência** e `protocolo`, nunca o id da OS (leia com `workOrders.list`). Recusa com HTTP 200 e `status: 0`: `REJECTED`, `effect: "unknown"` | parcial (sucesso: corpo mascarado, 1.x; a recusa é reconstruída) |
+| `occurrences.listTypes()`   | `GET /api/os/ocorrencia/tipo/list/` · query    | leitura  | `id` e `codigo`; `occurrences.create` usa o `codigo` em `ocorrenciatipo`                                                                                                          | observado (corpo mascarado, 1.x)                                 |
+| `occurrences.listMethods()` | `GET /api/ura/ocorrencia/metodo/list/` · query | leitura  |                                                                                                                                                                                   | observado (corpo mascarado, 1.x)                                 |
+
+### `documents`, `coverage`, `catalogs`, `experimental`
+
+| Método                                 | Rota e codificação                                                  | Natureza | Notas                                                                                                                                                | Evidência                                                 |
+| -------------------------------------- | ------------------------------------------------------------------- | -------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------- |
+| `documents.add(input)`                 | `PUT /api/suporte/cliente/{cliente_id}/documento/add/` · form-files | escrita  | Sucesso é 2xx com corpo **vazio** (`data: null`, nada identifica o documento); qualquer outro corpo 2xx é `INVALID_RESPONSE` com `effect: "unknown"` | reconstruído                                              |
+| `documents.list(input)`                | `GET /api/suporte/cliente/{cliente_id}/documento/list/` · query     | leitura  | `cliente_id` é um `CustomerId` positivo; array vazio = sem documentos                                                                                | observado (corpo mascarado, 1.x)                          |
+| `coverage.check(input)`                | `GET /api/ura/viabilidadeinstalacao` · query (sem barra final)      | leitura  | `gateway`, `raio` (metros) e `coordenada` (`"lat,lng"`) obrigatórios; o SDK não geocodifica; nada é convertido (o Geogrid manda números como texto)  | observado (corpo mascarado, 1.x; SGPMaps e Geogrid)       |
+| `catalogs.listPops()`                  | `POST /api/ura/pops/` · json                                        | leitura  |                                                                                                                                                      | observado (corpo mascarado, 1.x)                          |
+| `catalogs.listNas()`                   | `POST /api/ura/nas/list/` · json                                    | leitura  | `endereco_ip` é segredo                                                                                                                              | observado (corpo mascarado, 1.x)                          |
+| `catalogs.listBillingProfiles()`       | `GET /api/ura/portador/` · query                                    | leitura  | "Portadores" do SGP; os ids alimentam o filtro `portador` de `invoices.list`                                                                         | observado (corpo mascarado, 1.x)                          |
+| `experimental.annotations.list(input)` | `GET /api/ura/cliente/anotacao/list/` · query                       | leitura  | **Experimental.** Seleção local, corpo retido. Veja [leituras com escopo](#leituras-com-escopo)                                                      | reconstruído (corpo sintético; tipos de campo observados) |
+
+Todas as leituras acima aceitam `maxRetries`. `request(input, options?)` está descrita
+[acima](#request-chamada-bruta).
+
+## Migração do 1.x
+
+A 2.0 é uma quebra de contrato (resultado, códigos, nomes e comportamento), sem aliases. O mapa de
+cada método do 1.x e as mudanças de comportamento estão em [MIGRATION.md](MIGRATION.md); o histórico
+de mudanças, em [CHANGELOG.md](CHANGELOG.md).
+
+## Desenvolvimento
+
+Veja `CONTRIBUTING.md` no repositório. Os testes usam sempre um `fetch` injetado: nenhum teste
+toca o SGP, e a CI não usa credenciais.