sgp-sdk 1.2.0 → 2.0.0-beta.2

package/dist/result.d.ts

@@ -1,55 +1,127 @@
-/** Normalized failure category returned by every SDK method. */
-export type SgpErrorCode = "UNAUTHORIZED" | "ROUTE_NOT_ALLOWED" | "NOT_FOUND" | "METHOD_NOT_ALLOWED" | "VALIDATION" | "SCHEMA_MISMATCH" | "UPSTREAM" | "TIMEOUT" | "NETWORK" | "UNKNOWN";
-/** Normalized error. Never carries credentials, query strings, raw bodies or fetch exception messages. */
-export interface SgpError {
-    /** HTTP status, or 0 when no response was received. */
+/** Stable failure category of every 2.0 method. Branch on this, never on `message`. */
+export type SgpErrorCode = "INVALID_INPUT" | "UNAUTHORIZED" | "FORBIDDEN" | "RATE_LIMITED" | "ROUTE_NOT_ALLOWED" | "NOT_FOUND" | "REJECTED" | "UPSTREAM" | "NETWORK" | "TIMEOUT" | "ABORTED" | "INVALID_RESPONSE";
+/**
+ * What the SDK can affirm about the requested change of a write: `"none"` when it can affirm the
+ * change was not applied, `"unknown"` otherwise. Reads carry no effect.
+ */
+export type Effect = "none" | "unknown";
+/**
+ * Body of a captured response, as a discriminated value. `json` and `text` hold the decoded content
+ * (not the wire bytes); `unavailable` means the body started but could not be read to the end.
+ * `withheld` is a body the SDK received and deliberately did not keep: only
+ * `experimental.annotations.list` produces it, because its body holds other customers' notes.
+ */
+export type ResponseBody = {
+    kind: "json";
+    value: unknown;
+} | {
+    kind: "text";
+    text: string;
+} | {
+    kind: "empty";
+} | {
+    kind: "unavailable";
+    reason: "timeout" | "aborted" | "network";
+} | {
+    kind: "withheld";
+    reason: "bulk-privacy";
+};
+/** The HTTP response SGP sent: status, headers (lowercased names) and body. */
+export interface CapturedResponse {
+    /** HTTP status code SGP answered with. */
     status: number;
+    /**
+     * Header values as received, except that the credentials of the client are replaced by
+     * `<redacted>`: the value of any `token`/`app` parameter of a query or fragment, and the exact
+     * token or app (plain or URL-encoded) wherever it appears, when it has at least 8 characters.
+     */
+    headers: Readonly<Record<string, string>>;
+    /** The body as read; see {@link ResponseBody} for what each kind means. */
+    body: ResponseBody;
+}
+/** SGP's own error fields, values exactly as received. Only the keys present in the body appear. */
+export interface SgpErrorFields {
+    /** SGP's `detail` text, as received. */
+    detail?: unknown;
+    /** SGP's `msg` text, as received. */
+    msg?: unknown;
+    /** SGP's `error` text, as received. */
+    error?: unknown;
+    /** SGP's `errors`, as received: an object of field errors or an array of texts. */
+    errors?: unknown;
+}
+/** Normalized failure of a method. Never carries credentials, URLs or thrown objects. */
+export interface SgpError {
+    /** Stable failure category; branch on this. */
     code: SgpErrorCode;
     /** Written by the SDK, in English. */
     message: string;
+    /** Name of the operation that failed, e.g. `customers.list`. */
+    operation: string;
+    /** Operation-specific code, only where there is per-operation evidence. */
+    reason?: string;
+    /** What is known about the remote effect; set by writes only. */
+    effect?: Effect;
+    /** Projection of the SGP error fields found in the response body. */
+    sgp?: SgpErrorFields;
     /**
-     * Text from SGP's error body, copied verbatim (it can echo values from the request; the SDK adds
-     * nothing to it). Precedence: `detail` string, then non-empty `msg` string, then `errors`
-     * (array items, or `"key: value"` pairs from an object, joined by `"; "`), then non-empty
-     * `error` string. 401/403 are classified by it.
+     * On `INVALID_RESPONSE`: the paths that broke the contract, never values. On `INVALID_INPUT`:
+     * only when the SDK names the broken field (a `cpfcnpj` in a format no storing write accepts:
+     * `"cpfcnpj: expected ..."`); most local refusals carry none.
      */
-    detail?: string;
-    /** Request path only, without query string. */
-    endpoint: string;
+    issues?: readonly string[];
 }
-/** A non-key field whose type did not match the schema; reports type names, never values. */
+/** A hook that threw. Only its name and the attempt it ran on are kept, never the thrown value. */
+export interface Diagnostic {
+    /** Which hook threw. */
+    hook: "onRequest" | "onResponse" | "onError";
+    /** Attempt number (1-based) during which the hook ran. */
+    occurrence: number;
+}
+/** Fields every result carries, on success and on failure. */
+export interface ResultBase {
+    /** Requests the SDK started: 0 when refused locally, 1 for the first transport call. */
+    attempts: number;
+    /** Present only when a hook failed. */
+    diagnostics?: readonly Diagnostic[];
+}
+/**
+ * A field that did not have the type the method expects but is not essential to the response. The
+ * field left `data` and stays untouched in `response.body`, unless that body is `withheld` (then it
+ * is not recoverable). Type names only, never values.
+ */
 export interface SchemaWarning {
+    /** Where the mismatch is, with real indices: `clientes[0].contratos[1].status`. */
     path: string;
+    /**
+     * The field that is absent from `data` because of it. Equal to `path`, except when the mismatch is
+     * an array element: the whole array field is dropped (`clientes[0].contatos.emails`).
+     */
+    dropped: string;
+    /** Type the method expects (`string`, or `number | string` when several are accepted). */
     expected: string;
+    /** Type that arrived: `string`, `number`, `boolean`, `null`, `undefined`, `array` or `object`. */
     received: string;
 }
-/** Outcome of every SDK method; methods never throw for network, HTTP or schema failures. */
-export type SgpResult<T> = {
-    success: true;
+/** Successful call. `response` is the raw HTTP response the data came from. */
+export interface SgpSuccess<T> extends ResultBase {
+    /** Discriminant: `true` on success. */
+    ok: true;
+    /** What the method returns, decoded from the response. */
     data: T;
-    warnings?: SchemaWarning[];
-} | {
-    success: false;
+    /** The HTTP response `data` came from. */
+    response: CapturedResponse;
+    /** Present only when a non-essential field was dropped from `data`; see {@link SchemaWarning}. */
+    warnings?: readonly SchemaWarning[];
+}
+/** Failed call. `response` is `null` when no HTTP response was available. */
+export interface SgpFailure extends ResultBase {
+    /** Discriminant: `false` on failure. */
+    ok: false;
+    /** Why the call failed. */
     error: SgpError;
-};
-/**
- * Whether SGP applied a failed write: `"not_applied"` for a 4xx or a request rejected locally before
- * being sent (`VALIDATION`, status 0), `"unknown"` for everything else. The exception is SGP's
- * generic exception wrapper, a 4xx (in practice 400) whose body `errors` is an array (e.g.
- * `"Ocorreu um erro: ..."`): SGP may have failed after applying the write, so it is `"unknown"`.
- * 401/403/404/405/422 stay `"not_applied"`.
- */
-export type WriteOutcome = "not_applied" | "unknown";
-/** Normalized write error; `outcome` says whether the write may have taken effect. */
-export interface SgpWriteError extends SgpError {
-    outcome: WriteOutcome;
-}
-/** Outcome of every SDK write method; like reads, they never throw for network, HTTP or schema failures. */
-export type SgpWriteResult<T> = {
-    success: true;
-    data: T;
-    warnings?: SchemaWarning[];
-} | {
-    success: false;
-    error: SgpWriteError;
-};
+    /** The HTTP response received, or `null` when none was (refused locally, or the transport failed). */
+    response: CapturedResponse | null;
+}
+/** Outcome of every 2.0 method: expected failures are returned, never thrown. */
+export type SgpResult<T> = SgpSuccess<T> | SgpFailure;

package/dist/retry.d.ts

@@ -0,0 +1,34 @@
+import type { SgpFailure } from "./result.js";
+/**
+ * INTERNAL. The clock, the jitter and the wait of a call, injectable so retry timing is testable
+ * without real sleeps. Consumers never see it.
+ */
+export interface Runtime {
+    /** Epoch milliseconds. */
+    now: () => number;
+    /** In [0, 1). */
+    random: () => number;
+    /**
+     * Resolves after `ms`, or as soon as `signal` aborts (the executor then reads the budget's stop
+     * cause). Must release its timer and listener either way.
+     */
+    sleep: (ms: number, signal: AbortSignal) => Promise<void>;
+}
+export declare const defaultRuntime: Runtime;
+/**
+ * Whether the failure itself is the kind a repeat can fix: `RATE_LIMITED`, any `NETWORK`
+ * (the transport broke before or while reading the response, so nothing came of the attempt) and
+ * `UPSTREAM` with status 502, 503 or 504. A plain 500 is not on the list: it is as likely a
+ * deterministic bug of the route as a blip. The caller must still check the budget's stop cause.
+ */
+export declare const isTransientFailure: (failure: SgpFailure) => boolean;
+/**
+ * Wait before retry number `retryNumber` (1-based): "equal jitter" over an exponential ceiling,
+ * half fixed and half random, so a burst of clients spreads out without ever waiting zero.
+ */
+export declare const backoffMs: (retryNumber: number, random: () => number) => number;
+/**
+ * Milliseconds the server asked to wait: whole seconds, or an HTTP date relative to `now`. A past
+ * date is `0`. `undefined` when the header is absent or unreadable (the backoff then decides).
+ */
+export declare const parseRetryAfter: (value: string | null, now: number) => number | undefined;

package/dist/sensitivity.d.ts

@@ -1,7 +1,92 @@
+import type { Diagnostic, Effect, SchemaWarning, SgpErrorCode, SgpResult } from "./result.js";
 /**
- * Returns a shallow copy of `obj` without `keys`, typed accordingly.
+ * The keys of one kind of object that hold sensitive values. The same declaration describes the
+ * request fields (`input`) and the fields of the 2xx body (`output`, same shape as `data` and as
+ * `response.body.value`) of an operation.
+ */
+export interface SensitivityScope {
+    /**
+     * Where the objects are, in {@link pick} path syntax: `""` for the root object,
+     * `clientes[].contratos[]` for each contract of each customer.
+     */
+    path: string;
+    /** Credentials and network identifiers: Central/PPPoE logins and passwords, Wi-Fi, MAC, IP... */
+    secretKeys: readonly string[];
+    /** Personal data of a customer: name, document, address, contacts... A key covers its subtree. */
+    personalKeys: readonly string[];
+}
+/**
+ * What an operation declares as sensitive. Keys not listed are not "safe": the SDK treats every
+ * field it does not know as potentially sensitive, and so should the consumer (use {@link pick}).
+ */
+export interface OperationSensitivity {
+    /** Fields of the request. */
+    input: readonly SensitivityScope[];
+    /** Fields of the 2xx body. */
+    output: readonly SensitivityScope[];
+}
+/**
+ * Allowlist projection: a copy of `source` holding only the paths of `allowlist`. This is the way
+ * to hand anything to a log, a tool or an MCP server; never pass a result, `data` or `response`
+ * on as is.
+ *
+ * `source` is a `data` object or a whole result (then paths start at `data`, `error`, `response`,
+ * `attempts`...). Path syntax: keys joined by `.`, `[]` after a key for each element of an array
+ * (`clientes[].contratos[].id`), `[].id` for a root array. A path naming an object or array takes
+ * its whole subtree, which is the caller's explicit choice, with one exception: naming `response`
+ * alone takes neither `response.body` nor `response.headers`; those two come out only when a path
+ * names them exactly or goes below them (`response.body`, `response.headers.content-type`). Every
+ * key not named never comes out. A malformed path picks nothing. Only own, JSON-like values are
+ * copied. Depth is not bounded: do not hand it untrusted, arbitrarily deep input.
+ *
+ * Returns `{}` (or `[]`) when nothing matches.
+ */
+export declare const pick: (source: unknown, allowlist: readonly string[]) => unknown;
+/**
+ * What {@link toSafeLog} keeps of a result. Nothing of `data`, of the response (body and headers
+ * included) or of SGP's own error text.
+ */
+export interface SafeLog {
+    /** Whether the call succeeded. */
+    ok: boolean;
+    /** Requests the SDK started: 0 when refused locally. */
+    attempts: number;
+    /** Hooks that threw: name and attempt, never the thrown value. */
+    diagnostics?: readonly Diagnostic[];
+    /** Fields dropped from `data`: paths and type names, never values. */
+    warnings?: readonly SchemaWarning[];
+    /** Only the status of the HTTP response; no body, no headers. */
+    response?: {
+        /** HTTP status SGP answered with. */
+        status: number;
+    };
+    /** The failure, without SGP's own text. */
+    error?: {
+        /** Stable failure category. */
+        code: SgpErrorCode;
+        /** Written by the SDK, never by SGP. */
+        message: string;
+        /** Name of the operation that failed. */
+        operation: string;
+        /** Operation-specific code, where there is evidence for it. */
+        reason?: string;
+        /** What is known about the remote effect of a write. */
+        effect?: Effect;
+        /** Paths that broke the contract, never values. */
+        issues?: readonly string[];
+        /** Names of the SGP error fields that came (`detail`, `errors`...); their values stay out. */
+        sgpFields?: readonly string[];
+    };
+}
+/**
+ * A copy of a success or failure that is meant to be logged: outcome, attempts, status, error
+ * code, reason, effect and the names of the SGP fields that came. No `data`, no `response.body`,
+ * no headers, no value of SGP's error text (`error.sgp`, which echoes what was sent), and no
+ * credentials.
  *
- * Meant for the `secretKeys` / `personalKeys` tuples of an endpoint, so callers can drop sensitive
- * fields before logging or forwarding an item. Does not mutate `obj`.
+ * An aid, not a guarantee: it protects only what goes through it. `console.log(result)`,
+ * `structuredClone(result)`, a logger that walks the object, or any copy made before this call
+ * still sees everything. Log `toSafeLog(result)`, never the result. To log or send part of `data`,
+ * use {@link pick} with an explicit allowlist.
  */
-export declare const omitSensitive: <T extends object, K extends keyof T>(obj: T, keys: readonly K[]) => Omit<T, K>;
+export declare const toSafeLog: (result: SgpResult<unknown>) => SafeLog;

package/dist/tolerant.d.ts

@@ -0,0 +1,21 @@
+import type { z } from "zod";
+import type { DecodeOutcome } from "./operation.js";
+import type { ResponseBody } from "./result.js";
+/**
+ * The tolerant reader: validates a JSON body with `schema` and applies the fidelity policy.
+ *
+ * - A mismatch on one of the `invariants` (or anywhere the body cannot be read at all) is
+ *   `{ ok: false }`: the whole response is outside the contract.
+ * - Any other mismatch is tolerated: the offending field leaves its typed position (the nearest
+ *   enclosing object property when the issue sits on an array element), a warning with the precise
+ *   location and type names (never values) is returned, and the evidence is not touched because
+ *   this works on a copy.
+ * - An issue inside an array whose elements carry an invariant (an element that is not an object)
+ *   is an invariant failure; the array is never dropped silently.
+ * - Unknown keys are kept by the schema (loose objects), and nothing is ever invented.
+ *
+ * Invariants are declared per operation as paths: `clientes[].id`, with `[]` for any index. List the
+ * containers that must be readable too (`clientes`, `paginacao`), since a container is dropped
+ * like any other field unless it is an invariant.
+ */
+export declare const tolerantDecoder: <S extends z.ZodType>(schema: S, invariants: readonly string[]) => (body: ResponseBody) => DecodeOutcome<z.output<S>>;

package/dist/validation.d.ts

@@ -0,0 +1,3 @@
+import { z } from "zod";
+/** A string with something in it: not empty, not only whitespace. */
+export declare const nonBlank: z.ZodString;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sgp-sdk",
-  "version": "1.2.0",
+  "version": "2.0.0-beta.2",
   "description": "Unofficial TypeScript client for the SGP (TSMX) ISP ERP HTTP API, with normalized errors and explicit write outcomes. Not affiliated with TSMX.",
   "license": "MIT",
   "type": "module",
@@ -12,7 +12,10 @@
     }
   },
   "files": [
-    "dist"
+    "dist",
+    "MIGRATION.md",
+    "COMPATIBILITY.md",
+    "CHANGELOG.md"
   ],
   "engines": {
     "node": ">=22"
@@ -23,7 +26,7 @@
     "test": "bun test",
     "lint": "biome check .",
     "typecheck": "tsc --noEmit",
-    "check:consumer-types": "bun run build && tsc -p tests/consumer-types/tsconfig.json"
+    "check:consumer-types": "bun run build && tsc -p tests/consumer-types/tsconfig.json && tsc -p tests/consumer-types/tsconfig.bundler.json"
   },
   "dependencies": {
     "zod": "^4"

package/dist/endpoint.d.ts

@@ -1,66 +0,0 @@
-import type { z } from "zod";
-import type { SgpResult, SgpWriteResult } from "./result.js";
-import { type ParamValue, type RequestSpec, type SgpClientConfig, type SgpFile } from "./transport.js";
-/** Static description of one SGP route: how to call it, how to parse it and what is sensitive. */
-export interface EndpointDefinition<S extends z.ZodType> {
-    method: "GET" | "POST";
-    /** Request path starting with `/`; also the `endpoint` of every error. */
-    path: string;
-    schema: S;
-    /** Normalized paths of the required, strict fields (see `parseResponse`). */
-    keyFields: readonly string[];
-    /** Normalized path of the response items that carry sensitive keys, e.g. `clientes[]`. */
-    itemPath: string;
-    /** Keys of an item holding secrets (passwords, MACs, links with embedded token). */
-    secretKeys: readonly string[];
-    /** Keys of an item holding personal data (CPF/CNPJ, phone, e-mail, address, name). */
-    personalKeys: readonly string[];
-}
-/**
- * Static description of one SGP write route. Like {@link EndpointDefinition}, but `schema` is the
- * success body: a 2xx only counts as success when it validates (key fields present, right type).
- */
-export interface WriteEndpointDefinition<S extends z.ZodType> {
-    kind: "write";
-    method: "POST" | "PUT";
-    /** Request path template, e.g. `/api/crm/cliente/{cliente_id}/contratos/`; also the `endpoint` of every error. */
-    path: string;
-    schema: S;
-    /** Normalized paths of the required, strict fields (see `parseResponse`). */
-    keyFields: readonly string[];
-    /** Normalized path of the response items that carry sensitive keys. */
-    itemPath: string;
-    /** Keys of an item holding secrets. */
-    secretKeys: readonly string[];
-    /** Keys of an item holding personal data. */
-    personalKeys: readonly string[];
-}
-/** Inputs of one write call: values for the path placeholders, the request params and any files. */
-export interface WriteCall {
-    pathParams?: Record<string, string | number>;
-    params?: Record<string, ParamValue | undefined>;
-    files?: Record<string, SgpFile>;
-}
-/**
- * Sends the request described by `def` and parses the response with its schema.
- *
- * Never throws: transport and HTTP failures come back as `{ success: false, error }` and a body
- * that does not match the schema as `SCHEMA_MISMATCH`.
- */
-export declare const callEndpoint: <S extends z.ZodType>(config: SgpClientConfig, def: EndpointDefinition<S>, params?: RequestSpec["params"], pathParams?: RequestSpec["pathParams"]) => Promise<SgpResult<z.output<S>>>;
-/**
- * Sends the write described by `def` and tells whether SGP applied it.
- *
- * Never throws. Success is a 2xx whose body validates against `def.schema`. A failure carries an
- * `outcome`:
- * - `"not_applied"`: SGP answered 4xx and rejected the request, or the SDK rejected it locally before
- *   sending (invalid path params, `VALIDATION` with status 0);
- * - `"unknown"`: no response (timeout, network), 5xx, 3xx (redirects are never followed), a 4xx
- *   whose body `errors` is an array (SGP's generic exception wrapper, except 401/403/404/405/422),
- *   or a 2xx that is not a valid success (empty or non-JSON body, key field missing). The 2xx case
- *   is a `VALIDATION` error with the real HTTP status and, for a JSON body, SGP's own text
- *   (`detail`/`msg`/`errors`/`error`) or else the failing paths.
- *
- * Never retried by the SDK. With `outcome: "unknown"`, check the state in SGP before repeating.
- */
-export declare const callWriteEndpoint: <S extends z.ZodType>(config: SgpClientConfig, def: WriteEndpointDefinition<S>, call?: WriteCall) => Promise<SgpWriteResult<z.output<S>>>;

package/dist/endpoints/crm/address.d.ts

@@ -1,20 +0,0 @@
-/**
- * Address as SGP takes it. Pass it once: the SDK serializes it both nested (`endereco`) and as
- * loose fields (`logradouro`, `numero`, ...), which are the two formats the CRM routes read.
- */
-export interface SgpAddress {
-    logradouro: string;
-    numero?: string | number;
-    complemento?: string;
-    bairro: string;
-    cidade: string;
-    cep: string;
-    uf: string;
-    pais?: string;
-    pontoreferencia?: string;
-    /** Map position, `"lat,lng"`. */
-    map_ll?: string;
-    condominio?: string | number;
-}
-/** The address as a plain record with the same keys and no `undefined` ones. */
-export declare const flatAddress: (address: SgpAddress) => Record<string, string | number>;

package/dist/endpoints/crm/create-contract.d.ts

@@ -1,109 +0,0 @@
-import { z } from "zod";
-import type { WriteEndpointDefinition } from "../../endpoint.js";
-import type { ParamValue } from "../../transport.js";
-import { type SgpAddress } from "./address.js";
-/** SGP's billing methods, by the `forma_cobranca_codigo` it takes. */
-export declare const formaCobrancaCodigo: {
-    readonly boleto: 1;
-    readonly debitoAutomatico: 2;
-    readonly carne: 3;
-    readonly cobrancaRecorrente: 4;
-    readonly pix: 6;
-};
-/** A valid `forma_cobranca_codigo` of `POST /api/crm/cliente/{cliente_id}/contratos/`. */
-export type FormaCobrancaCodigo = (typeof formaCobrancaCodigo)[keyof typeof formaCobrancaCodigo];
-/**
- * SGP's equipment acquisition modes, by the `modoaquisicao` it takes: 0 Próprio and 1 Comodato.
- * SGP rejects any other value (2 included), although its Postman collection lists 1 and 2.
- */
-export declare const modoAquisicao: {
-    readonly proprio: 0;
-    readonly comodato: 1;
-};
-/** A valid `modoaquisicao` of `POST /api/crm/cliente/{cliente_id}/contratos/`. */
-export type ModoAquisicao = (typeof modoAquisicao)[keyof typeof modoAquisicao];
-/**
- * Success body of `POST /api/crm/cliente/{cliente_id}/contratos/`: the new contract ID, SGP's
- * message and the customer's name.
- */
-export declare const createContractSchema: z.ZodObject<{
-    message: z.ZodNullable<z.ZodOptional<z.ZodString>>;
-    clientecontrato: z.ZodNumber;
-    cliente: z.ZodNullable<z.ZodOptional<z.ZodString>>;
-}, z.core.$strip>;
-/** Key fields of `crm/cliente/{cliente_id}/contratos/`: required and strict; a 2xx without them is not a success. */
-export declare const createContractKeyFields: readonly ["clientecontrato"];
-/** Normalized path of the created contract in the response (the root object). */
-export declare const contractCreatedItemPath = "";
-/** Keys of the response holding secrets (none in `crm/cliente/{cliente_id}/contratos/`). */
-export declare const contractCreatedSecretKeys: readonly [];
-/** Keys of the response holding personal data: `cliente` is the customer's name. */
-export declare const contractCreatedPersonalKeys: readonly ["cliente"];
-/** Parsed response of `POST /api/crm/cliente/{cliente_id}/contratos/`. */
-export type CreateContractResponse = z.output<typeof createContractSchema>;
-/**
- * Params of `POST /api/crm/cliente/{cliente_id}/contratos/`; `cliente_id` goes in the path.
- * `login`, `senha`, `central_login`, `central_senha`, the addresses and the network fields
- * (`ip`, `mac`, `mac_dhcp`) are secret or personal data.
- */
-export interface CreateContractParams {
-    pop_id: number;
-    plano_id: number;
-    /** Payer or financial responsible. */
-    portador_id: number;
-    forma_cobranca_codigo: FormaCobrancaCodigo;
-    /** Due day registered in SGP. */
-    vencimento_dia: number;
-    /** Sent nested and also as the loose fields (`logradouro`, `numero`, ...) SGP reads. */
-    endereco_instalacao: SgpAddress;
-    endereco_cobranca: SgpAddress;
-    /** PPPoE login and password: SGP requires them for an internet service. */
-    login?: string;
-    senha?: string;
-    modoaquisicao?: ModoAquisicao;
-    /** Name of the NAS. */
-    nas?: string;
-    /** Exempt percentage. */
-    isento?: number;
-    autocobranca?: boolean;
-    servicodesc?: string;
-    observacao?: string;
-    vendedor_id?: number;
-    /** 1 = percentage, 2 = fixed amount. */
-    comissao_tipo?: 1 | 2;
-    comissao?: number;
-    /** Contract group for printing. */
-    contrato_id?: number;
-    fidelidade_id?: number;
-    midia_id?: number;
-    central_login?: string;
-    central_senha?: string;
-    ip?: string;
-    ippool_id?: number;
-    mac_dhcp?: string;
-    mac?: string;
-    logins_simult?: number;
-    splitter_id?: number;
-    splitter_port?: number;
-    tipo_equipamento?: string;
-    usuarioalt_id?: number;
-    /** Opens the installation service order, without a date. */
-    os_instalacao?: boolean;
-    /** Text of the installation occurrence. */
-    conteudo?: string;
-    instalacao_quantidade_parcelas?: number;
-    instalacao_preco?: number;
-    instalacao_desconto?: number;
-    instalacao_entrada?: number;
-    instalacao_entrada_forma?: number;
-    instalacao_parcela_forma?: number;
-    instalacao_portador?: number;
-}
-/**
- * Request body of the contract route: the params, with both addresses nested and the installation
- * one also as loose fields beside them (SGP describes those as "installation and billing").
- * `undefined` address keys are omitted in both formats.
- */
-export declare const toContractBody: (params: CreateContractParams) => Record<string, ParamValue | undefined>;
-/** Definition of `POST /api/crm/cliente/{cliente_id}/contratos/` (trailing slash required by the token whitelist). */
-export declare const createContractDefinition: WriteEndpointDefinition<typeof createContractSchema>;

package/dist/endpoints/crm/create-customer.d.ts

@@ -1,65 +0,0 @@
-import { z } from "zod";
-import type { WriteEndpointDefinition } from "../../endpoint.js";
-import type { ParamValue } from "../../transport.js";
-import { type SgpAddress } from "./address.js";
-/** Success body of `POST /api/crm/cliente/{F|J}`: the new CRM customer ID and SGP's message. */
-export declare const createCustomerSchema: z.ZodObject<{
-    cliente_id: z.ZodNumber;
-    message: z.ZodNullable<z.ZodOptional<z.ZodString>>;
-}, z.core.$strip>;
-/** Key fields of `crm/cliente/{F|J}`: required and strict; a 2xx without them is not a success. */
-export declare const createCustomerKeyFields: readonly ["cliente_id"];
-/** Normalized path of the created customer in the response (the root object). */
-export declare const customerCreatedItemPath = "";
-/** Keys of the response holding secrets (none in `crm/cliente/{F|J}`). */
-export declare const customerCreatedSecretKeys: readonly [];
-/** Keys of the response holding personal data: SGP's message carries the name and CPF/CNPJ. */
-export declare const customerCreatedPersonalKeys: readonly ["message"];
-/** Parsed response of `POST /api/crm/cliente/F` and `POST /api/crm/cliente/J`. */
-export type CreateCustomerResponse = z.output<typeof createCustomerSchema>;
-/** Params of `POST /api/crm/cliente/F` (individual). Name, CPF and address are personal data. */
-export interface CreateIndividualCustomerParams {
-    nome: string;
-    cpfcnpj: string;
-    endereco: SgpAddress;
-    email?: string;
-    celular?: string;
-    /** `"DD/MM/AAAA"`. */
-    datanasc?: string;
-    observacao?: string;
-    rg?: string;
-    rg_emissor?: string;
-    sexo?: "M" | "F";
-    /** C = married, S = single, V = widowed, D = divorced. */
-    estadocivil?: "C" | "S" | "V" | "D";
-    nomemae?: string;
-    nomepai?: string;
-    profissao?: string;
-    nacionalidade?: string;
-    naturalidade?: string;
-}
-/** Params of `POST /api/crm/cliente/J` (company). Name, CNPJ and address are personal data. */
-export interface CreateCompanyCustomerParams {
-    nome: string;
-    cpfcnpj: string;
-    endereco: SgpAddress;
-    nomefantasia?: string;
-    respempresa?: string;
-    respcpf?: string;
-    insc_estadual?: string;
-    insc_municipal?: string;
-    email?: string;
-    celular?: string;
-    /** `"DD/MM/AAAA"`. */
-    datafundacao?: string;
-    observacao?: string;
-}
-/**
- * Request body of the customer routes: the params, with the address nested (`endereco`) and also
- * as loose fields beside them, as SGP reads both. `undefined` address keys are omitted in both.
- */
-export declare const toCustomerBody: (params: CreateIndividualCustomerParams | CreateCompanyCustomerParams) => Record<string, ParamValue | undefined>;
-/** Definition of `POST /api/crm/cliente/F` (individual customer). */
-export declare const createIndividualCustomerDefinition: WriteEndpointDefinition<typeof createCustomerSchema>;
-/** Definition of `POST /api/crm/cliente/J` (company customer). */
-export declare const createCompanyCustomerDefinition: WriteEndpointDefinition<typeof createCustomerSchema>;