@tslite/checker 0.14.0 → 1.1.0

package/dist/types/index.d.cts

@@ -0,0 +1,948 @@
+/** Uma propriedade de um tipo objeto. */
+interface Prop {
+    readonly type: Schema;
+    /** `true` quando a propriedade pode estar ausente (`{ x?: T }`). */
+    readonly optional?: boolean;
+}
+/**
+ * Assinatura de índice de um objeto — `{ [k: string]: V }` (a forma de `Record<K, V>`).
+ * Coexiste com props nomeadas (`{ a: number; [k: string]: unknown }`), como no TS.
+ * O domínio da chave é só `string`/`number` (o que o TS permite).
+ */
+interface IndexSig {
+    readonly key: "string" | "number";
+    readonly value: Schema;
+}
+/**
+ * Flag de um elemento de tupla, na forma da 3.9 (DECISIONS D49 da raiz):
+ * - `req` — elemento posicional normal (`A` em `[A, B]`);
+ * - `optional` — `A?` (pode estar ausente; `[A, B?]`); só TRAILING, posicional;
+ * - `rest` — `...T[]` (cauda de array); o tipo do elemento é o do array. Só no FIM.
+ */
+type ElementFlag = "req" | "optional" | "rest";
+/** Um parâmetro de um tipo função. */
+interface Param {
+    readonly name: string;
+    readonly type: Schema;
+    /** `true` quando o argumento pode ser omitido. */
+    readonly optional?: boolean;
+    /** `true` para o parâmetro rest (`...args: T[]`). */
+    readonly variadic?: boolean;
+}
+/**
+ * Type predicate `(v) => v is S` — quando a fn devolve `true`, o argumento na
+ * posição `param` é estreitado para `type` (S). `returns` da fn continua `boolean`
+ * (é o que roda); o `guard` é a info de narrowing. `filter`/`find` inferem S dele;
+ * `if (g(x))` estreita `x` (D13). Covariante em `type`.
+ */
+interface GuardSig {
+    readonly param: number;
+    readonly type: Schema;
+}
+/**
+ * Um type parameter — a ENTIDADE do tsc (`TypeParameter`), numa forma só para
+ * todo lugar que declara (`fn`/assinatura de `overload`, `TypeScheme`, `infer`).
+ *
+ * Tem dois papéis, como no tsc, onde a ocorrência de `T` no corpo **é** o objeto
+ * declarado:
+ * - **declaração** (nas listas `typeParams`/`params`/`infer`): a autoridade — nome,
+ *   `bound` e `default`;
+ * - **ocorrência** (no corpo): nome e `bound`, que é o que a álgebra lê sem conhecer
+ *   o binder (`apparentType` de `T extends C` é `C`, TC26). O `default` só existe na
+ *   declaração: só a aridade o usa.
+ *
+ * A identidade é o NOME no escopo do binder, não a referência (o `Schema` é JSON
+ * imutável, TC17) — daí o `substitute` evitar captura (TC37).
+ *
+ * É um alias de tipo, e não uma `interface`, como todo membro da união `Schema`: só o
+ * alias ganha a assinatura de índice implícita, e é ela que deixa o `Schema` caber em
+ * `Record<string, unknown>` — o que um consumidor que recebe um tipo como objeto
+ * genérico espera (TC41).
+ */
+type VarSchema = {
+    readonly t: "var";
+    readonly name: string;
+    /** `extends bound` — a constraint (TC10). */
+    readonly bound?: Schema;
+    /** `= default` — só na DECLARAÇÃO (TC37). */
+    readonly default?: Schema;
+};
+/**
+ * O tipo de um valor na linguagem TSLite.
+ *
+ * O discriminador é `t`. Estruturas (object/array/union/fn) referenciam outros
+ * `Schema` recursivamente — inclusive de forma cíclica (ex.: `Node` que contém
+ * `Node[]`); as operações que percorrem `Schema` são cycle-safe.
+ */
+type Schema = {
+    readonly t: "any";
+} | {
+    readonly t: "unknown";
+} | {
+    readonly t: "string";
+} | {
+    readonly t: "number";
+} | {
+    readonly t: "boolean";
+} | {
+    readonly t: "null";
+} | {
+    readonly t: "undefined";
+} | {
+    readonly t: "void";
+}
+/**
+ * A keyword `object` — o NÃO-PRIMITIVO (o `nonPrimitiveType` do tsc,
+ * `checker.ts:735`). Aceita objeto, array, tupla e função; recusa todo primitivo,
+ * `null` e `undefined`. A forma inspecionável dele é `{}` (TC54), então ler uma
+ * propriedade falha.
+ *
+ * O kind não se chama `object` porque esse nome é do objeto ESTRUTURAL (TC22); é o
+ * `format` que o imprime `object`, como lá.
+ */
+ | {
+    readonly t: "nonPrimitive";
+} | {
+    readonly t: "literal";
+    readonly value: string | number | boolean;
+    /**
+     * `fresh` = literal "fresco" de uma EXPRESSÃO de valor (`1`, `"x"`) — alarga
+     * pra base em posição de membro (array/object/tupla) ou inferido num `T[]`,
+     * mas preserva no topo (`const x = 1` → `1`; `id(1)` → `1`). Literal de
+     * `keyof`/declarado é NÃO-fresh → nunca alarga. Transparente p/ subtype/equals.
+     */
+    readonly fresh?: boolean;
+} | {
+    readonly t: "object";
+    readonly props: Readonly<Record<string, Prop>>;
+    /** Assinatura de índice (`Record<K, V>`); coexiste com `props`. Ausente = objeto fechado. */
+    readonly index?: IndexSig;
+    /** A ORIGEM: este tipo nasceu de um literal escrito no código — ver {@link fromLiteral}. */
+    readonly fromLiteral?: boolean;
+    /**
+     * O literal que o originou tinha um **spread** (`{ ...o, a: 1 }`) — o
+     * `ObjectFlags.ContainsSpread` do tsc. Só o widening o lê: um membro assim não
+     * CONTRIBUI as suas chaves para os irmãos de uma união (mas recebe as deles).
+     * Ver {@link widenObjectLiteral} e TC53.
+     */
+    readonly hasSpread?: boolean;
+} | {
+    readonly t: "array";
+    readonly items: Schema;
+    /**
+     * `readonly T[]` (o `ReadonlyArray<T>` do TS). Só afeta a RELAÇÃO, e num
+     * sentido: `T[] ≤ readonly T[]`, mas **não** o contrário — dar um readonly
+     * onde se espera mutável perderia a garantia. TC28.
+     */
+    readonly readonly?: boolean;
+    /** A ORIGEM: este tipo nasceu de um literal escrito no código — ver {@link fromLiteral}. */
+    readonly fromLiteral?: boolean;
+} | {
+    readonly t: "tuple";
+    readonly elements: readonly Schema[];
+    readonly flags?: readonly ElementFlag[];
+    /** `readonly [A, B]` — mesma regra do array readonly (TC28). */
+    readonly readonly?: boolean;
+    /** A ORIGEM: este tipo nasceu de um literal escrito no código — ver {@link fromLiteral}. */
+    readonly fromLiteral?: boolean;
+} | {
+    readonly t: "union";
+    readonly of: readonly Schema[];
+} | {
+    readonly t: "fn";
+    readonly params: readonly Param[];
+    readonly returns: Schema;
+    /** Type predicate `(v) => v is S` — narrowing (ver `GuardSig`). */
+    readonly guard?: GuardSig;
+    /**
+     * As DECLARAÇÕES dos type params, em ordem (`<T, K extends keyof T = D>`).
+     * Ausente = a assinatura **não é genérica** — que é o que o tsc diz quando
+     * `Signature.typeParameters` é `undefined`.
+     *
+     * A ordem é a declarada, nunca a da aparição das `var`: sem ela não dá para
+     * ligar o `f<T>(x)` nem checar aridade, e o tsc trata a chamada como
+     * não-genérica (TS2558). Cada entrada é a declaração inteira (TC37).
+     */
+    readonly typeParams?: readonly VarSchema[];
+} | {
+    readonly t: "overload";
+    readonly signatures: readonly {
+        readonly t: "fn";
+        readonly params: readonly Param[];
+        readonly returns: Schema;
+        readonly guard?: GuardSig;
+        /** As declarações dos type params desta assinatura (ver o `fn` acima). */
+        readonly typeParams?: readonly VarSchema[];
+    }[];
+} | {
+    readonly t: "keyof";
+    readonly of: Schema;
+} | {
+    readonly t: "index";
+    readonly obj: Schema;
+    readonly key: Schema;
+} | {
+    readonly t: "mapped";
+    readonly key: string;
+    readonly over: Schema;
+    readonly body: Schema;
+    readonly optional?: boolean;
+} | {
+    readonly t: "conditional";
+    readonly check: Schema;
+    readonly extends: Schema;
+    readonly then: Schema;
+    readonly else: Schema;
+    readonly infer?: readonly VarSchema[];
+} | {
+    readonly t: "intersection";
+    readonly of: readonly Schema[];
+} | {
+    readonly t: "returnType";
+    readonly fn: Schema;
+} | {
+    readonly t: "parameters";
+    readonly fn: Schema;
+} | VarSchema | {
+    /**
+     * `typeof x` em posição de TIPO — o *type query* do TS.
+     *
+     * É o único nó do vocabulário que **não** se resolve pela álgebra: ele
+     * pergunta o tipo de um **VALOR**, e valor é assunto do escopo, que este
+     * package não conhece (zero-dep, por desenho). Quem resolve é o checker,
+     * no ponto de USO — espelhando o `getTypeFromTypeQueryNode` do tsc, que é
+     * lazy (`links.resolvedType`) pelo mesmo motivo.
+     *
+     * Um `typeQuery` que chegue à álgebra é sinal de que a resolução não
+     * aconteceu (nome inexistente — já reportado); os algoritmos o tratam como
+     * folha opaca, sem estourar.
+     */
+    readonly t: "typeQuery";
+    /** O entity name, em partes: `typeof obj.m` → `["obj", "m"]`. */
+    readonly path: readonly string[];
+} | {
+    readonly t: "apply";
+    readonly name: string;
+    readonly args: readonly Schema[];
+};
+type AnySchema = Extract<Schema, {
+    t: "any";
+}>;
+type UnknownSchema = Extract<Schema, {
+    t: "unknown";
+}>;
+type LiteralSchema = Extract<Schema, {
+    t: "literal";
+}>;
+type ObjectSchema = Extract<Schema, {
+    t: "object";
+}>;
+type ArraySchema = Extract<Schema, {
+    t: "array";
+}>;
+type TupleSchema = Extract<Schema, {
+    t: "tuple";
+}>;
+type UnionSchema = Extract<Schema, {
+    t: "union";
+}>;
+type FnSchema$1 = Extract<Schema, {
+    t: "fn";
+}>;
+type OverloadSchema = Extract<Schema, {
+    t: "overload";
+}>;
+type KeyofSchema = Extract<Schema, {
+    t: "keyof";
+}>;
+type IndexSchema = Extract<Schema, {
+    t: "index";
+}>;
+type MappedSchema = Extract<Schema, {
+    t: "mapped";
+}>;
+type ConditionalSchema = Extract<Schema, {
+    t: "conditional";
+}>;
+type ApplySchema = Extract<Schema, {
+    t: "apply";
+}>;
+type ScalarSchema = Extract<Schema, {
+    t: "string" | "number" | "boolean" | "null" | "undefined";
+}>;
+/**
+ * Um *type scheme*: um tipo nomeado parametrizado, `type Pair<A, B> = body`.
+ * `params` são as DECLARAÇÕES dos type params (na ordem); `body` é o `Schema` que
+ * as usa via `var`. Um tipo nomeado não-genérico é só um scheme com `params: []`.
+ *
+ * Cada declaração carrega o `extends` (`bound`) e o `=` (`default`), como a do
+ * `fn` — a mesma entidade (TC37): um param com default pode ser omitido na
+ * aplicação (`Box` ≡ `Box<number>` para `type Box<T = number>`), o default pode
+ * citar os params anteriores (`<T, U = T[]>`), e um arg tem de caber no bound
+ * (TS2344). Quem os cobra é a aplicação (`expand`, o checker).
+ */
+interface TypeScheme {
+    readonly params: readonly VarSchema[];
+    readonly body: Schema;
+}
+/** Registro de type schemes por nome — consultado pela expansão (ver `expand`). */
+type Schemes = Readonly<Record<string, TypeScheme>>;
+declare const s: {
+    readonly any: Schema;
+    readonly unknown: Schema;
+    readonly string: Schema;
+    readonly number: Schema;
+    readonly boolean: Schema;
+    readonly null: Schema;
+    readonly undefined: Schema;
+    readonly void: Schema;
+    /** A keyword `object`: o não-primitivo (TC54). */
+    readonly nonPrimitive: Schema;
+    readonly literal: (value: string | number | boolean) => Schema;
+    readonly object: (props: Record<string, Prop>, index?: IndexSig) => Schema;
+    /** `Record<K, V>` — objeto só com assinatura de índice `{ [k: K]: V }`. */
+    readonly record: (value: Schema, key?: "string" | "number") => Schema;
+    readonly array: (items: Schema, ro?: boolean) => Schema;
+    /**
+     * Tupla `[A, B]`, `[A, B?]` ou `[A, ...B[]]` — comprimento e posições conhecidos.
+     *
+     * O elemento **opcional** nasce com `undefined` no tipo, e é por isso que ninguém
+     * precisa lembrar de pedi-lo depois: é o `getTypeFromOptionalTypeNode` do tsc
+     * (`checker.ts:12229`), `strictNullChecks ? getOptionalType(type) : type` ao ler o
+     * nó `number?` — e é o que faz ele imprimir `[string, (number | undefined)?]`.
+     *
+     * A flag `optional` continua marcando a ARIDADE (o `minLength`), que é a outra
+     * pergunta: `[A, B?]` tem comprimento `1 | 2`, e é isso que o separa de
+     * `[A, B | undefined]`, que o tsc recusa um contra o outro. O `rest` NÃO ganha
+     * `undefined` — lá ele não passa por esse nó.
+     */
+    readonly tuple: (elements: readonly Schema[], flags?: readonly ElementFlag[], ro?: boolean) => Schema;
+    /**
+     * `typeParams` são as DECLARAÇÕES dos type params, em ordem (`s.typeParam`) —
+     * omitir significa "não é genérica" (e um `f<T>(x)` sobre ela vira erro de
+     * aridade, como no tsc). As `var` do corpo carregam a mesma constraint (TC37).
+     */
+    readonly fn: (params: Param[], returns: Schema, typeParams?: readonly VarSchema[]) => Schema;
+    /** Type predicate `(…) => v is S` — fn que devolve `boolean` e estreita o param `i`. */
+    readonly guard: (params: Param[], type: Schema, param?: number) => Schema;
+    /**
+     * Overload: o mesmo valor com várias assinaturas de chamada (a 1ª que casa
+     * vence). Ex. Ramda `add`: `[(a,b)=>number, (a)=>(b)=>number]`.
+     */
+    readonly overload: (signatures: FnSchema$1[]) => Schema;
+    /** `keyof T` — a união (de literais) das chaves de `T`. Resolve quando `T` é concreto. */
+    readonly keyof: (of: Schema) => Schema;
+    /** `T[K]` — acesso indexado. Resolve quando `T` é objeto/array e `K` é literal/união. */
+    readonly index: (obj: Schema, key: Schema) => Schema;
+    /** `{ [key in over]?: body }` — mapped type. Resolve quando `over` dá chaves literais. */
+    readonly mapped: (key: string, over: Schema, body: Schema, optional?: boolean) => Schema;
+    /** `check extends ext ? then : els` — conditional. `infer` = as declarações dos
+     *  `infer U` introduzidos no `ext` (as posições são `var(U)`); resolve via `unify`
+     *  (ver `resolveConditional`). Sem `infer` → conditional simples (discriminante concreto). */
+    readonly conditional: (check: Schema, ext: Schema, then: Schema, els: Schema, infer?: readonly VarSchema[]) => Schema;
+    /** `A & B` — interseção. Funde objetos concretos; lazy com `var`. */
+    /**
+     * `A & B`, pelas leis do reticulado — o construtor NORMALIZA (TC20), como o
+     * `s.union` absorve o topo (TC44): `& never` é `never`, o escalar disjunto zera
+     * (`number & string`, `1 & 2`, `"a" & undefined` → `never`) e a subsunção mantém o
+     * mais estreito (`string & "x"` → `"x"`). Medido na 3.9.10, é o que o
+     * `getIntersectionType` faz — e são os mesmos vereditos.
+     *
+     * Sem isto a interseção disjunta atravessava intacta e contaminava quem a
+     * contivesse: `null[] | ("a" & undefined)` deixava de ser reflexivo, onde no tsc a
+     * união é só `null[]`.
+     */
+    readonly intersection: (of: readonly Schema[]) => Schema;
+    /** Açúcar para `A & B` (dois membros). */
+    readonly and: (a: Schema, b: Schema) => Schema;
+    /** `ReturnType<F>` — o retorno de uma `fn`. Resolve quando `F` é concreto. */
+    readonly returnType: (fn: Schema) => Schema;
+    readonly parameters: (fn: Schema) => Schema;
+    /** A OCORRÊNCIA de um type param (`T` no corpo), com a constraint da declaração. */
+    readonly var: (name: string, bound?: Schema) => VarSchema;
+    /**
+     * A DECLARAÇÃO de um type param (`<K extends C = D>`) — a entrada das listas
+     * `fn.typeParams`, `TypeScheme.params` e `conditional.infer` (TC37). As
+     * ocorrências no corpo são `s.var(name, bound)`.
+     */
+    readonly typeParam: (name: string, decl?: {
+        bound?: Schema;
+        default?: Schema;
+    }) => VarSchema;
+    /**
+     * `typeof x` em posição de tipo. Resolvido pelo **checker** (precisa do escopo
+     * de valor), não pela álgebra — ver o JSDoc do nó `typeQuery`.
+     */
+    readonly typeQuery: (path: readonly string[]) => Schema;
+    /** Construtor de tipo aplicado: `apply("Map", [K, V])` ⇒ `Map<K, V>`. */
+    readonly apply: (name: string, args?: readonly Schema[]) => Schema;
+    /** Açúcar para `Promise<T>` — o que `await` desembrulha. */
+    readonly promise: (value: Schema) => Schema;
+    /**
+     * A união, pela forma CANÔNICA barata — o `getUnionType` do tsc no modo padrão
+     * (`UnionReduction.Literal`, `checker.ts:12362`), passo a passo:
+     *
+     * - achata as aninhadas, e o `never` some (o `addTypesToUnion`);
+     * - **absorve o topo**: com `any` é `any`, com `unknown` é `unknown` (TC44);
+     * - **deduplica** o que lá tem a mesma identidade: a mesma referência, e as FOLHAS
+     *   por valor (primitivos e literais são internados lá). Dois objetos iguais de
+     *   origens diferentes NÃO se unem aqui — lá também não: têm identidades distintas,
+     *   e uni-los é a redução por SUBTIPO, que é o {@link normalizeUnion}, sob pedido;
+     * - tira o literal que a base já cobre (`"a" | string` é `string` — o
+     *   `removeRedundantLiteralTypes`), e `true | false` é `boolean` (lá `boolean` É
+     *   essa união, internada; aqui é kind próprio — TC23);
+     * - zero membros é `never`, e UM membro é ele mesmo.
+     *
+     * É a porta única: um tipo que o tsc não saberia construir não deve existir (TC50).
+     */
+    readonly union: (of: readonly Schema[]) => Schema;
+};
+/** Resolve um `keyof`/`index` um nível quando possível; senão, devolve `t` como está. */
+declare function resolveTypeOp(t: Schema): Schema;
+/**
+ * O acesso indexado cuja chave **não existe** no objeto — o que o tsc reporta como
+ * TS2339 e resolve para o `errorType` (`getIndexedAccessType`:
+ * `getIndexedAccessTypeOrUndefined(…) || (accessNode ? errorType : unknownType)`).
+ *
+ * É um `unknown` de identidade única, como o {@link silentNever} é um `never` (TC39):
+ * quem tem o NÓ da anotação o reconhece por referência, reporta e o troca pelo
+ * tipo-erro; quem não tem lê um `unknown` — o que o tsc faz sem `accessNode`. A
+ * identidade não sobrevive a `JSON.stringify` nem à reconstrução do nó, e não
+ * precisa: ela vive entre a resolução e quem a consulta.
+ */
+declare const missingType: Schema;
+/** O acesso indexado resolveu para "a chave não existe"? (identidade, não forma.) */
+declare const isMissingType: (t: Schema) => boolean;
+/**
+ * A ORIGEM de um tipo de objeto, array ou tupla: ele nasceu de um **literal escrito no
+ * código** (`{ a: 1 }`, `["a"]`) e não de uma anotação ou de um alias. É o
+ * `ObjectFlags.ObjectLiteral | ArrayLiteral` do tsc — *"originates in an object/array
+ * literal"* (`types.ts:4498` e `4507` na tag).
+ *
+ * **Não é frescura.** No tsc as duas marcas convivem e são lidas por quem responde a
+ * perguntas diferentes: a `FreshLiteral` some quando o tipo é regularizado
+ * (`getRegularTypeOfObjectLiteral` faz `objectFlags & ~FreshLiteral`) e é o que a
+ * checagem de propriedade excedente lê; a de ORIGEM **nunca** é removida, sobrevive ao
+ * widening, e é o que a INFERÊNCIA lê (`isObjectOrArrayLiteralType`, `checker.ts:19138`).
+ *
+ * Aqui só a origem mora no tipo. A frescura continua vindo do NÓ — o `ObjectExpression`
+ * numa borda contextual —, que é a decisão do checker D47 e responde bem onde ela é
+ * usada. A origem não pode vir do nó: a inferência roda na álgebra, longe dele.
+ *
+ * Para que serve: o `getCovariantInference` junta os candidatos de origem literal num só
+ * antes de escolher o supertipo comum, e é isso que faz `f({ a: 1 }, 1)` inferir `1`
+ * (com o literal acusado) enquanto `f(o, 1)` com `o` declarado infere `{ a: number }`
+ * (com o `1` acusado). Sem a marca, o erro sai no argumento errado (TC47).
+ */
+declare const isObjectOrArrayLiteral: (t: Schema) => boolean;
+/** O mesmo tipo marcado como vindo de um literal escrito (ver {@link isObjectOrArrayLiteral}). */
+declare const asLiteralOrigin: (t: Schema) => Schema;
+declare const ownProp: (props: Readonly<Record<string, Prop>>, key: string) => Prop | undefined;
+/**
+ * Separa `undefined` de um tipo: devolve o tipo **sem** `undefined` e se ele estava
+ * presente. Em posição de **propriedade**, `T | undefined` é uma propriedade
+ * **opcional** de tipo `T` — espelha o `JSON.stringify` (chave `undefined` some).
+ * Só mexe em `undefined`, nunca em `null` (que é valor JSON presente). Usado pelo
+ * `serializable` e pelo `toJsonSchema` (mesma regra dos dois lados).
+ */
+declare function withoutUndefined(t: Schema): {
+    type: Schema;
+    hadUndefined: boolean;
+};
+/**
+ * Nome de propriedade NUMÉRICO canônico — o `isNumericLiteralName` do tsc: o texto é
+ * exatamente `ToString(ToNumber(texto))`. `"1"`, `"-1"`, `"0.5"`, `"1e+21"`, `"NaN"`,
+ * `"Infinity"` são; `"01"`, `"1.0"`, `"-0"`, `"1e3"`, `"x"` não. É o que uma index
+ * signature `number` alcança: só essas chaves; as demais ficam livres.
+ */
+declare const isNumericLiteralName: (name: string) => boolean;
+
+/** A flag do elemento `i` de uma tupla (ausente = `req`). */
+declare const flagAt: (t: TupleSchema, i: number) => ElementFlag;
+/** A tupla termina num elemento `rest`? (senão tem comprimento limitado; `optional`
+ *  NÃO conta). */
+declare const isVariadicTuple: (t: TupleSchema) => boolean;
+/** O índice do elemento `rest` (sempre o último), ou -1. */
+declare const restIndex: (t: TupleSchema) => number;
+
+type IncompatibilityKind = "missing" | "type";
+/** Um ponto de incompatibilidade entre `actual` e `expected`. */
+interface Incompatibility {
+    /** Caminho até o ponto: `[]` = raiz, `["count"]`, `["user","name"]`. */
+    readonly path: readonly string[];
+    /** O tipo esperado naquele ponto. */
+    readonly expected: Schema;
+    /** O tipo que veio — ausente quando `kind === "missing"` (a prop não existe). */
+    readonly actual?: Schema;
+    readonly kind: IncompatibilityKind;
+}
+/** Renderiza um `typeDiff` numa frase legível (o feedback que brilha). Missing
+ *  são AGREGADOS (como o tsc: "missing the following properties: a, b, c"). */
+declare function formatTypeDiff(incs: readonly Incompatibility[]): string;
+
+/**
+ * `typeDiff(a, b)` — POR QUE `a ⊄ b`: lista de incompatibilidades com caminho +
+ * razão (≅ a elaboração do tsc). É o `subtype` em **modo elaboração** (uma fonte de
+ * verdade, sem walk paralelo — a lição do `propertiesRelatedTo`). Caminho FRIO: roda
+ * só ao reportar; NÃO usa o relation cache. `[]` = compatível.
+ */
+declare function typeDiff(a: Schema, b: Schema, schemes?: Schemes): Incompatibility[];
+/** `true` se um valor de tipo `a` pode ser usado onde se espera `b`. */
+declare function subtype(a: Schema, b: Schema, schemes?: Schemes): boolean;
+/**
+ * `true` se `a` é COMPARÁVEL a `b` — o `isTypeComparableTo` do tsc, a relação que
+ * decide se uma asserção de tipo se sobrepõe. É direcional como o `subtype` (a
+ * estrutura do alvo continua sendo exigida da origem), mas folgada onde o tsc a
+ * folga: folhas nas duas direções, união na origem por algum membro, `unknown`
+ * sobreposto a tudo, prop opcional lida como `T | undefined`. A regra completa do
+ * `as` (alargar a origem e testar os dois sentidos) é de quem tipa a asserção.
+ */
+declare function comparable(a: Schema, b: Schema, schemes?: Schemes): boolean;
+/** Igualdade estrutural: cada um é atribuível ao outro. */
+declare function equals(a: Schema, b: Schema, schemes?: Schemes): boolean;
+/**
+ * Resolve um conditional `check extends ext ? then : else` escolhendo o ramo —
+ * **só quando o discriminante é ground** (sem `var` livre em `check`/`extends`),
+ * via `subtype(check, ext)`. Com var no discriminante → `null` (fica lazy até o
+ * `substitute` ligar as vars). Os ramos `then`/`else` podem ter vars (resolvem
+ * depois). É o análogo do `resolveTypeOp`/`resolveMapped` para conditionals.
+ */
+declare function resolveConditional(c: ConditionalSchema, schemes: Schemes): Schema | null;
+type FnSchema = Extract<Schema, {
+    t: "fn";
+}>;
+/**
+ * O tipo do argumento na posição `i` — o `tryGetTypeAtPosition` do tsc: o parâmetro
+ * fixo; depois dele, o elemento do rest (array) ou a posição do rest (tupla).
+ * `undefined` sem parâmetro ali, ou com rest genérico (`...args: T`), que só se
+ * resolve instanciado.
+ */
+declare function typeAtPosition(sig: FnSchema, i: number): Schema | undefined;
+/**
+ * Normaliza uma união: achata, absorve `any`/`unknown`, deduplica e remove
+ * membros subsumidos por outro (`string | "x"` → `string`). Colapsa união de um
+ * membro no próprio membro. União vazia permanece vazia (renderiza `never`).
+ *
+ * É a redução por SUBTIPO do tsc — o `getUnionType` com `UnionReduction.Subtype`,
+ * pedido explicitamente por quem a quer (o `getCommonSupertype`, o widening de uma
+ * união com `{}`, os candidatos de inferência). O construtor `s.union` faz só a
+ * barata; esta custa uma relação por par (TC50).
+ */
+declare function normalizeUnion(members: readonly Schema[]): Schema;
+
+/**
+ * Profundidade máxima de **comparações aninhadas** na relação — o `depth` do
+ * `recursiveTypeRelatedTo` do tsc, que corta em 100 (`checker.ts:16217` na tag) e
+ * reporta "Excessive stack depth comparing types" (TS2321).
+ *
+ * É o número do tsc, não um acima dele: todo teto nosso é ≤ ao dele (DECISIONS D50 da
+ * raiz), porque o checker roda no navegador do cliente e não num build. Medido, a folga
+ * é grande — a suíte inteira alcança 5 comparações aninhadas no `@tslite/types` e 14 no
+ * `@tslite/checker`, e a pilha do V8 aguenta ~1561. O profile pode apertar
+ * ({@link configureTypeLimits}); afrouxar acima de 100 é defeito.
+ */
+declare const TYPE_EVAL_DEPTH_LIMIT = 100;
+/**
+ * Profundidade máxima de **instanciação** — o `instantiationDepth` do tsc, que corta em
+ * 50 (`instantiateType`, `checker.ts:14293`) e reporta TS2589. É outro eixo que o da
+ * relação: ali se COMPARA, aqui se CONSTRÓI um tipo novo a cada passo, e é o que um
+ * genérico que se instancia sem fim faz crescer.
+ */
+declare const INSTANTIATION_DEPTH_LIMIT = 50;
+/**
+ * Teto de **contagem** de instanciações, por expressão — o `instantiationCount` do tsc
+ * (5.000.000 na mesma linha), zerado a cada `checkExpression`/`checkSourceElement`
+ * (`checker.ts:29192`, `34607`). Ele pega o que a profundidade não pega: uma explosão
+ * LARGA, em que cada instanciação é rasa mas há milhões delas.
+ */
+declare const INSTANTIATION_COUNT_LIMIT = 5000000;
+/** Os tetos de avaliação de tipo (Proposal 003), todos ≤ aos do tsc (D50 da raiz):
+ *  `maxTypeDepth` ↔ TS2321 (relação); `maxInstantiationDepth`/`maxInstantiationCount` ↔
+ *  TS2589 (instanciação); `maxUnionMembers` ↔ TS2590; `maxOverloadSignatures` é nosso (o
+ *  tsc não tem teto ali). */
+interface TypeEvalLimits {
+    readonly maxTypeDepth: number;
+    readonly maxInstantiationDepth: number;
+    readonly maxInstantiationCount: number;
+    readonly maxUnionMembers: number;
+    readonly maxOverloadSignatures: number;
+}
+/** Default standalone (quando o `@tslite/types` roda sem profile — infer/json-schema).
+ *  Cada número é o do tsc ou menor (D50): nenhum deles é escolha nossa "folgada". */
+declare const DEFAULT_TYPE_LIMITS: TypeEvalLimits;
+/** Configura os tetos globais (o checker chama no início de `check()` a partir do
+ *  profile). Mescla sobre o default. Resetar com {@link resetTypeLimits} no finally. */
+declare function configureTypeLimits(limits: Partial<TypeEvalLimits>): void;
+/** Volta aos defaults (chamado no `finally` do consumidor). */
+declare function resetTypeLimits(): void;
+/** Os tetos ativos no momento (lido pela álgebra: `subtype`/`normalizeUnion`). */
+declare function typeLimits(): TypeEvalLimits;
+/** Lançado quando a avaliação de tipo excede a profundidade (`maxTypeDepth`) — o
+ *  "Excessive stack depth comparing types" do tsc (TS2321). */
+declare class TypeEvalLimitError extends Error {
+    constructor(depth?: number);
+}
+/**
+ * Lançado quando a INSTANCIAÇÃO excede a profundidade ou a contagem — o
+ * "Type instantiation is excessively deep and possibly infinite" do tsc (TS2589), que
+ * usa a mesma mensagem para os dois tetos.
+ *
+ * É erro próprio, e não o {@link TypeEvalLimitError}, porque o eixo é outro: lá se
+ * compara dois tipos, aqui se constrói um novo a cada passo. O consumidor mapeia os dois
+ * para `too-deep` (o catálogo do checker tem um código por conceito), e a MENSAGEM diz
+ * qual é o caso.
+ */
+declare class InstantiationLimitError extends Error {
+    readonly kind: "depth" | "count";
+    constructor(kind: "depth" | "count", limit?: number);
+}
+/**
+ * Contagem de instanciações da expressão atual — o `instantiationCount` do tsc, que é
+ * zerado a cada expressão checada (`checker.ts:29192`), e não somado pelo programa
+ * inteiro. O consumidor chama isto onde o tsc zera; sem chamar, o teto vale para a
+ * checagem toda, que é mais apertado (nunca mais frouxo).
+ */
+declare function resetInstantiationCount(): void;
+/** Lançado quando uma união excede `maxUnionMembers` (fiel ao TS2590 do tsc:
+ *  "Expression produces a union type that is too complex to represent"). */
+declare class UnionTooComplexError extends Error {
+    constructor(count: number, limit?: number);
+}
+
+/** As features de tipo gateadas presentes em `schema` (recursivo, cycle-safe).
+ *  `recursionName` (o nome do alias sendo autorado) liga a detecção de `recursion`. */
+declare function typeFeatures(schema: Schema, recursionName?: string): Set<string>;
+
+/** Ligações `nome da var → tipo` (o resultado de `unify`/aplicação de scheme). */
+type Bindings = Readonly<Record<string, Schema>>;
+/** Uma assinatura: um `fn` ou uma entrada de `overload.signatures`. */
+type Signature = FnSchema$1 | OverloadSchema["signatures"][number];
+/**
+ * Aplica `bindings` a `schema`, trocando cada `var` ligada pelo seu tipo.
+ *
+ * Cada nó substituído conta para o teto de CONTAGEM (o `instantiationCount` do tsc, 5M
+ * por expressão) — é a medida do trabalho de instanciação, e pega a explosão LARGA que
+ * a profundidade não vê. A **profundidade** não é cobrada aqui, e o motivo está no
+ * {@link expand1}: descer a árvore de um tipo grande não é "instanciação aninhada".
+ */
+declare function substitute(schema: Schema, bindings: Bindings, seen?: WeakSet<object>): Schema;
+/**
+ * A assinatura com os type params que ela declara renomeados para fora de `avoid`
+ * (`U` → `U_1`, a convenção do tsc), nas declarações e nas ocorrências. É a
+ * separação que o tsc tem de graça por identidade de objeto: ao relacionar duas
+ * assinaturas, o `U` que uma declara não pode ser confundido com um `U` livre da outra.
+ */
+declare function renameTypeParams<S extends Signature>(sig: S, avoid: ReadonlySet<string>): S;
+/** Os nomes de `var` LIVRES em `schema` — os que um binder declara não entram (TC37). */
+declare function freeVars(schema: Schema): ReadonlySet<string>;
+
+/**
+ * O curinga "sem inferência" — o `silentNeverType` do tsc: um `never` que ocupa, no
+ * contextual que uma chamada passa a uma chamada genérica aninhada, o lugar de um type
+ * param dela que ainda não tem candidato (o `getInferredType` com `NoDefault`). Nada se
+ * infere dele. É comparado por IDENTIDADE, como lá, e não é dado persistível: vive só
+ * durante a inferência de uma chamada.
+ */
+declare const silentNever: Schema;
+/**
+ * Os candidatos de inferência de uma var, na ORDEM em que a inferência os encontrou —
+ * o `InferenceInfo.candidates`/`contraCandidates` do tsc. Duas listas, porque a
+ * POSIÇÃO em que o candidato foi achado decide como ele vale: o que veio de um
+ * PARÂMETRO de função é contravariante (TC48).
+ */
+interface VarCandidates {
+    readonly co: Schema[];
+    readonly contra: Schema[];
+}
+/**
+ * O tipo inferido de uma var a partir dos seus candidatos — o `getCovariantInference`
+ * do tsc (`checker.ts:19156`), em TRÊS etapas: os de origem literal se juntam num só
+ * (posto no fim), o resto decide o supertipo comum, e o que sai passa pelo
+ * {@link widenOrigin} — o `getWidenedType` que fecha a função lá (`checker.ts:19174`),
+ * e que é o que completa uma união de literais com as chaves dos irmãos (TC53).
+ */
+declare function covariantInference(candidates: readonly Schema[], schemes?: Schemes): Schema | undefined;
+/**
+ * O tipo inferido de uma var a partir dos candidatos CONTRAVARIANTES — o
+ * `getContravariantInference` do tsc (`checker.ts:19152`), que sem a prioridade de
+ * combinação é o `getCommonSubtype` (`checker.ts:17700`): o menor deles, pelo
+ * `reduceLeft` com a relação invertida.
+ */
+declare function contravariantInference(candidates: readonly Schema[], schemes?: Schemes): Schema | undefined;
+/**
+ * A decisão de UMA var, com as duas listas — o `getInferredType` do tsc
+ * (`checker.ts:19177`).
+ *
+ * Havendo candidatos contravariantes, eles têm a preferência, **salvo** quando o
+ * covariante existe, não é `never` e é subtipo deles. É essa exceção que faz
+ * `k((x) => {}, 1)` com `<T,>(f: (x: T) => void, v: T): T` inferir `1` e não `number`:
+ * o `number` do parâmetro do callback é contravariante, o `1` do argumento é
+ * covariante, e `1 ≤ number` — então vence o `1`.
+ */
+declare function inferFromCandidates(slot: VarCandidates, schemes?: Schemes): Schema | undefined;
+
+/** `getErasedSignature` do tsc: os type params da assinatura viram `any`. É o que a
+ *  inferência faz com uma assinatura-ALVO genérica — os type params dela não são
+ *  candidatos da chamada de fora, e não podem vazar para as ligações dela. */
+declare function erasedSignature(sig: FnSchema$1): FnSchema$1;
+/**
+ * O tipo inferido de cada type param declarado — o `getInferredType` do tsc: o
+ * candidato; sem ele, o default (instanciado com o que já foi inferido), senão
+ * `unknown`; e o que não cabe na constraint, candidato ou default, vira a constraint.
+ * As ligações que não são dos declarados atravessam como estão.
+ */
+declare function inferredTypes(decls: readonly VarSchema[], b: Bindings, schemes?: Schemes): Bindings;
+/**
+ * O `instantiateSignatureInContextOf` do tsc, para relacionar uma assinatura-FONTE
+ * genérica com uma assinatura-ALVO: os type params da fonte são inferidos dos
+ * parâmetros do alvo (posição a posição) e, para o que eles não ligaram, do retorno —
+ * a prioridade menor do tsc (`InferencePriority.ReturnType`). O resto passa pelo
+ * `inferredTypes`. Os type params do ALVO ficam como estão: rígidos, o canônico do tsc.
+ * Devolve a fonte instanciada, não-genérica.
+ */
+declare function instantiateInContextOf(sig: FnSchema$1, context: FnSchema$1, schemes?: Schemes): FnSchema$1;
+/**
+ * Liga as `var`s de `pattern` aos tipos correspondentes em `actual`. Devolve as
+ * ligações estendidas, ou `null` se forem incompatíveis. `actual` que seja
+ * `any`/`unknown` não constrange vars (deixa-as livres).
+ */
+declare function unify(pattern: Schema, actual: Schema, bindings?: Bindings): Bindings | null;
+/** Resultado de instanciar uma assinatura contra argumentos. */
+interface Instantiation {
+    readonly returns: Schema;
+    readonly bindings: Bindings;
+}
+/**
+ * Instancia uma função genérica: unifica cada argumento contra o parâmetro
+ * correspondente (ligando as `var`s) e devolve o retorno já substituído.
+ * Falha (`null`) se algum argumento não unificar. Um parâmetro `variadic`
+ * absorve os argumentos restantes (cada um unifica contra o tipo do rest).
+ */
+declare function instantiate(sig: FnSchema$1, args: readonly Schema[], schemes?: Schemes): Instantiation | null;
+/**
+ * Versão tolerante de {@link instantiate} para o editor/checker: nunca falha —
+ * argumentos que não unificam são ignorados, e `var`s não ligadas permanecem
+ * (útil para aplicação parcial e enquanto o usuário ainda digita).
+ */
+declare function instantiateLoose(sig: FnSchema$1, args: readonly Schema[], schemes?: Schemes): Instantiation;
+/**
+ * Aterra as `var`s remanescentes em `unknown` (para exibição do resultado). Resolve
+ * de passagem um `conditional` cujo discriminante já é ground → o tipo do resultado
+ * sai concreto (ex.: `ReturnType<F>` aplicado vira o retorno real). `schemes` é
+ * preciso pra resolver conditionals que checam contra type aliases.
+ */
+declare function groundVars(schema: Schema, schemes?: Schemes, seen?: WeakSet<object>, depth0?: number, 
+/** Nomes que NÃO são aterrados: as vars RÍGIDAS de quem chama (o `T` da função
+ *  genérica que envolve a chamada), que no tsc continuam `T` no resultado. */
+keep?: ReadonlySet<string>): Schema;
+
+/**
+ * O supremo estrutural de `a` e `b`: o menor `Schema` ao qual ambos são
+ * atribuíveis. `unknown` é a unidade (sem-evidência); `any` é absorvente.
+ */
+declare function join(a: Schema, b: Schema): Schema;
+/**
+ * Dobra uma lista de formas no seu supremo comum. Lista vazia → `never` (⊥, a
+ * identidade do supremo). Um membro → ele mesmo. É a operação do schema-reducer:
+ * `joinAll(amostras.map(inferValue))` descreve todas as amostras.
+ */
+declare function joinAll(members: readonly Schema[]): Schema;
+
+/**
+ * A aridade de uma lista de type params — de um alias (`TypeScheme.params`) ou de
+ * uma assinatura (`fn.typeParams`), que são a mesma entidade (TC37): `min` são os
+ * params até o último sem default, `max` são todos. Uma aplicação com `n`
+ * argumentos cabe quando `min ≤ n ≤ max`; os que faltam vêm do default. É o
+ * `getMinTypeArgumentCount` do tsc, que também serve aos dois.
+ */
+declare function typeParamArity(params: readonly VarSchema[]): {
+    min: number;
+    max: number;
+};
+/**
+ * As ligações de uma aplicação: `param_i → arg_i`, e os params que faltam recebem
+ * o default — substituído com o que já foi ligado, para `<T, U = T[]>` dar
+ * `U = number[]` em `Pair<number>`. É o `fillMissingTypeArguments` do tsc.
+ */
+declare function bindTypeParams(params: readonly VarSchema[], args: readonly Schema[]): Record<string, Schema>;
+/** Há um scheme registrado para este `apply` (com aridade compatível)? */
+declare function isScheme(t: Schema, schemes: Schemes): boolean;
+/**
+ * Expande **um nível**: `apply(name, args)` com scheme registrado vira
+ * `substitute(body, { param_i → args_i })` — os params omitidos vêm do default.
+ * Qualquer outro tipo (ou `apply` opaco) é devolvido intacto.
+ *
+ * **Não há contador de profundidade aqui, e isso é estrutural.** No tsc a instanciação
+ * aninha — o `instantiateType` de um objeto cria um tipo com membros LAZY, e ler um
+ * membro dispara outra instanciação DENTRO da primeira, que é o que o
+ * `instantiationDepth` (50) conta. Aqui a expansão é um passo PURO sobre uma árvore
+ * imutável: expande um nível, devolve, e quem chamou segue — nunca uma expansão dentro
+ * de outra. Quem limita esta dimensão é o desdobramento em LOOP de quem consome
+ * (`apparentType`, `resolveApplied`, `evalKeys`), e o teto deles é o
+ * `maxInstantiationDepth` — o mesmo 50 do tsc (DECISIONS D50 da raiz).
+ */
+declare function expand1(t: Schema, schemes: Schemes): Schema;
+
+/**
+ * Normaliza `t` até a forma que dá para INSPECIONAR (ler props, extrair chaves):
+ *
+ * - `var T extends C` → `C` (a constraint; o `getBaseConstraintOfType` do tsc);
+ * - `apply("X")` COM scheme registrado → expande **um nível** e continua (lazy,
+ *   para tipo recursivo terminar). Sem scheme, fica opaco — é a ilha nominal
+ *   legítima (`Promise`, `Map`), TC2;
+ * - `mapped` concreto → o objeto resultante;
+ * - `intersection` → a forma canônica (membros aparentes);
+ * - o resto → ele mesmo.
+ *
+ * Idempotente e cycle-safe por profundidade. NÃO resolve operadores de tipo —
+ * isso é do `resolveTypeOp`; aqui só se prepara o OPERANDO (ver `resolveOp`).
+ */
+declare function apparentType(t: Schema, schemes?: Schemes, depth?: number): Schema;
+/**
+ * Resolve um operador de tipo (`keyof`/`T[K]`/`ReturnType`) **ciente de schemes**:
+ * normaliza o OPERANDO com {@link apparentType} e então resolve. É o que faz
+ * `keyof Property` virar `"id" | "title"` como no tsc.
+ *
+ * Devolve o próprio `t` quando não há o que resolver (operando genérico) — a
+ * mesma semântica do `resolveTypeOp`, então é substituível onde os `schemes`
+ * estiverem disponíveis.
+ */
+declare function resolveOp(t: Schema, schemes?: Schemes): Schema;
+
+/**
+ * Um valor JSON do tipo — o que um campo recém-criado contém.
+ *
+ * | tipo | valor |
+ * | --- | --- |
+ * | `string` · `number` · `boolean` · `null` | `""` · `0` · `false` · `null` |
+ * | literal | o próprio literal |
+ * | array | `[]` |
+ * | tupla | cada posição obrigatória com o seu exemplo; opcional e rest ausentes |
+ * | objeto | as propriedades **obrigatórias** preenchidas; as opcionais ausentes |
+ * | record / só índice | `{}` |
+ * | interseção de objetos | a mescla (a forma aparente) |
+ * | união que contém `null` | `null` — o inicial de algo anulável é a ausência |
+ * | outra união | o exemplo do primeiro membro que não seja `undefined` |
+ * | tipo nomeado / scheme | o exemplo do tipo expandido |
+ * | `unknown` · `any` · função · `undefined` · `void` · o que não tem valor JSON | `null` |
+ *
+ * Um valor preenchido por esta regra é atribuível ao próprio schema, para todo
+ * tipo que descreve dado — é o que evita um segundo `missing-properties` no
+ * lugar do primeiro.
+ */
+declare function sampleValue(schema: Schema, schemes?: Schemes): unknown;
+
+/** Alarga um literal FRESH pra sua base; mantém não-fresh e não-literais. Raso —
+ *  usado por elemento na CONSTRUÇÃO de array/object/tupla literal (no checker). */
+declare function widen(t: Schema): Schema;
+/**
+ * O `getWidenedLiteralType` do tsc (`checker.ts:25661`): alarga literal **fresh**
+ * e **distribui sobre união** — `1 | 2` (frescos) vira `number`. Mantém não-fresh.
+ *
+ * É a regra do binding MUTÁVEL: `let n = 1` é `number`, `const c = 1` é `1`
+ * (`getWidenedLiteralTypeForInitializer`, `checker.ts:41456` — const/readonly
+ * mantém, o resto alarga). Sem isto, `let n = 1; n = 2` erraria, porque o binding
+ * teria ficado com o tipo `1`.
+ *
+ * Difere do `widen` (raso, sem união) e do `widenType` (fundo, entra em
+ * membro): aqui é só o TOPO, distribuindo em união — exatamente o do tsc.
+ */
+declare function widenLiteral(t: Schema): Schema;
+/**
+ * O `getBaseTypeOfLiteralType` do tsc: TODO literal vira a sua base — fresco ou não —
+ * e distribui sobre união (`"a" | "b"` → `string`).
+ *
+ * É o que a asserção de tipo faz com a ORIGEM antes de medir sobreposição: em
+ * `(x: 1) => x as 2` a origem vale `number`, que se sobrepõe a `2`. Difere do
+ * `widenLiteral`, que só alarga o literal fresco — um parâmetro anotado `1` não é
+ * fresco, e mesmo assim a asserção o lê pela base.
+ */
+declare function baseLiteralType(t: Schema): Schema;
+/**
+ * Widening TOTAL (`getWidenedType` do TS): alarga todo literal fresh, **inclusive
+ * o do topo**. É a regra do **retorno de função** (`() => 1` → `() => number`;
+ * `async () => 1` → `Promise<number>`). Literal não-fresh (keyof) é mantido.
+ */
+declare function widenType(t: Schema): Schema;
+/**
+ * A regra de widening do TS para o RESULTADO (const / retorno de chamada): alarga
+ * literais fresh em posição de **membro** (aninhados), mas mantém um literal fresh
+ * no **topo**. `id(1)` → `1`; `wrap(1)` (`T[]`) → `number[]`; `keys` (`keyof T`) →
+ * mantém (não-fresh).
+ */
+declare function widenInferred(t: Schema): Schema;
+/**
+ * O `getWidenedType` do tsc (`checker.ts:18112`) — ver o bloco acima. Aplica-se
+ * onde um tipo de expressão vira o tipo de um LUGAR: o candidato de uma inferência
+ * (o fim do `getCovariantInference`), uma declaração sem anotação
+ * (`widenTypeForVariableLikeDeclaration`) e o retorno inferido de uma função.
+ *
+ * Não confundir com o {@link widenType}, que é o widening de LITERAL (`1` → `number`)
+ * e roda em outros pontos: os dois são independentes, e o tsc também os separa.
+ */
+declare function widenOrigin(t: Schema): Schema;
+
+/**
+ * A forma de topo de um tipo impresso, para decidir parênteses. Um printer de tipo —
+ * este, do `Schema`, e o de type-node do `@tslite/format` — classifica o nó numa forma
+ * e pergunta à escada (`typeNeedsParens`): uma escada, duas renderizações.
+ */
+type TypeForm = "function" | "conditional" | "union" | "intersection" | "operator" | "query" | "primary";
+/**
+ * As posições da gramática de tipos e o que cada uma NÃO aceita sem parênteses — a
+ * escada do `factory/parenthesizerRules.ts` do tsc (`parenthesizeCheckTypeOfConditionalType`
+ * até `parenthesizeNonArrayTypeOfPostfixType`). Os ramos do conditional, o retorno de
+ * função, o elemento de tupla, a prop e o parâmetro aceitam qualquer tipo.
+ */
+declare const NEEDS_PARENS: {
+    readonly check: Set<TypeForm>;
+    readonly extends: Set<TypeForm>;
+    readonly union: Set<TypeForm>;
+    readonly intersection: Set<TypeForm>;
+    readonly operand: Set<TypeForm>;
+    readonly postfix: Set<TypeForm>;
+};
+/** Uma posição da gramática de tipos (ver `NEEDS_PARENS`). */
+type TypePosition = keyof typeof NEEDS_PARENS;
+/** Um tipo de forma `form` precisa de parênteses na posição `pos`? */
+declare const typeNeedsParens: (pos: TypePosition, form: TypeForm) => boolean;
+/** Renderiza `schema` como uma string no estilo TypeScript. */
+declare function format(schema: Schema, seen?: WeakSet<object>): string;
+/**
+ * Os argumentos de tipo de uma lista (`A, B`, sem os `<>`), com a regra do 1º argumento
+ * (`(<T>(x: T) => T), B`). Para quem monta a lista fora de um `apply` — o argumento de
+ * tipo de uma chamada (`f<T>(x)`), no emissor de fonte.
+ */
+declare function formatTypeArgs(args: readonly Schema[]): string;
+
+/**
+ * `true` quando `schema` descreve **dado puro** (sobrevive a `JSON.stringify`
+ * sem perda silenciosa). `fn` é o ponto-chave: uma função é dropada em silêncio
+ * pela serialização — por isso `false`.
+ *
+ * `apply` é **conservador** (`false`): sem registro de construtores-de-dado
+ * liberados, não dá pra garantir que `Foo<…>` (ou `Promise<T>`, `Map<K,V>`)
+ * vire JSON. `var` (forma desconhecida), `any`/`unknown` (sem garantia) → `false`.
+ */
+declare function isSerializable(schema: Schema, seen?: WeakSet<object>): boolean;
+
+/** Um membro que pode seguir a partir de um tipo (item de autocomplete). */
+interface Completion {
+    /** Nome da propriedade, ou `"[]"` para o elemento de um array. */
+    readonly key: string;
+    readonly type: Schema;
+    readonly optional: boolean;
+}
+/** Resultado de navegar um path: o tipo final + o que pode seguir dele. */
+interface Discovery {
+    readonly type: Schema;
+    readonly completions: readonly Completion[];
+}
+/**
+ * Navega `path` a partir de `schema`. Retorna o tipo alcançado e suas
+ * completions, ou `null` se algum segmento não existir no tipo. Path vazio
+ * devolve o próprio tipo e suas completions.
+ */
+declare function discover(schema: Schema, path: readonly string[], schemes?: Schemes): Discovery | null;
+
+export { type AnySchema, type ApplySchema, type ArraySchema, type Bindings, type Completion, DEFAULT_TYPE_LIMITS, type Discovery, type ElementFlag, type FnSchema$1 as FnSchema, type GuardSig, INSTANTIATION_COUNT_LIMIT, INSTANTIATION_DEPTH_LIMIT, type Incompatibility, type IncompatibilityKind, type IndexSchema, type Instantiation, InstantiationLimitError, type KeyofSchema, type LiteralSchema, type MappedSchema, type ObjectSchema, type OverloadSchema, type Param, type Prop, type ScalarSchema, type Schema, type Schemes, TYPE_EVAL_DEPTH_LIMIT, type TupleSchema, TypeEvalLimitError, type TypeEvalLimits, type TypeForm, type TypePosition, type TypeScheme, type UnionSchema, UnionTooComplexError, type UnknownSchema, type VarCandidates, type VarSchema, apparentType, asLiteralOrigin, baseLiteralType, bindTypeParams, comparable, configureTypeLimits, contravariantInference, covariantInference, discover, equals, erasedSignature, expand1, flagAt, format, formatTypeArgs, formatTypeDiff, freeVars, groundVars, inferFromCandidates, inferredTypes, instantiate, instantiateInContextOf, instantiateLoose, isMissingType, isNumericLiteralName, isObjectOrArrayLiteral, isScheme, isSerializable, isVariadicTuple, join, joinAll, missingType, normalizeUnion, ownProp, renameTypeParams, resetInstantiationCount, resetTypeLimits, resolveConditional, resolveOp, resolveTypeOp, restIndex, s, sampleValue, silentNever, substitute, subtype, typeAtPosition, typeDiff, typeFeatures, typeLimits, typeNeedsParens, typeParamArity, unify, widen, widenInferred, widenLiteral, widenOrigin, widenType, withoutUndefined };