@tslite/checker 1.8.0 → 1.12.0

package/dist/index.d.ts

@@ -1,1078 +1 @@
-import { VarSchema, Schema, Schemes, TypeScheme, ObjectSchema, Completion } from './types/index.js';
-export { AnySchema, ApplySchema, ArraySchema, Bindings, Candidates, DEFAULT_TYPE_LIMITS, Discovery, ElementFlag, FnSchema, GuardSig, INSTANTIATION_COUNT_LIMIT, INSTANTIATION_DEPTH_LIMIT, Incompatibility, IncompatibilityKind, IndexSchema, InferencePriority, Instantiation, InstantiationLimitError, KeyofSchema, LiteralSchema, MappedSchema, OverloadSchema, Param, PathSegment, Prop, ScalarSchema, TYPE_EVAL_DEPTH_LIMIT, TupleSchema, TypeEvalLimitError, TypeEvalLimits, TypeForm, TypePosition, UnionSchema, UnionTooComplexError, UnknownSchema, VarCandidates, WriteKey, apparentType, asLiteralOrigin, baseLiteralType, bindTypeParams, comparable, configureTypeLimits, contravariantInference, covariantInference, createInferences, discover, equals, erasedSignature, expand1, flagAt, format, formatTypeArgs, formatTypeDiff, freeVars, groundVars, inferFromCandidates, inferTypes, inferredBindings, inferredTypes, instantiateInContextOf, instantiateLoose, isMissingType, isNumericLiteralName, isObjectOrArrayLiteral, isScheme, isSerializable, isVariadicTuple, join, joinAll, missingType, normalizeUnion, ownProp, readonlyMember, renameTypeParams, resetInstantiationCount, resetTypeLimits, resolveConditional, resolveOp, resolveTypeOp, restIndex, restTypeAtPosition, s, sampleValue, silentNever, substitute, subtype, typeAtPosition, typeDiff, typeFeatures, typeLimits, typeNameOf, typeNeedsParens, typeParamArity, version, widen, widenInferred, widenLiteral, widenOrigin, widenType, withUndefined, withoutUndefined } from './types/index.js';
-import { BaseNode, Scope as Scope$1, Node, types, SourceLocation, Expression } from '@tslite/ast';
-import { CapabilityProfile, CompiledProfile } from '@tslite/capability';
-import { Span } from '@tslite/language-service';
-
-/** As declarações de tipo nominal: o nome e os type params, em ordem. */
-type Nominals = Readonly<Record<string, readonly VarSchema[]>>;
-
-/** O que uma declaração de namespace declara com um nome. */
-interface NamespaceMember {
-    /** Visível de fora: tem `export`, ou está num contexto ambiente que exporta tudo. */
-    readonly exported: boolean;
-    /** O nome, onde o diagnóstico sobre a declaração pousa; `null` num membro do ambiente,
-     *  que não tem texto. */
-    readonly id: BaseNode | null;
-    /** A chave do tipo no catálogo, quando não é o nome qualificado (`path.nome`): a de um
-     *  tipo que outra declaração do mesmo namespace também declara (checker D88). */
-    readonly key?: string;
-}
-/** Uma declaração de namespace — um bloco. `namespace A.B { … }` são duas: o `A` e o `B`. */
-interface NamespaceDeclaration {
-    /** O `TSModuleDeclaration`; `null` num namespace do ambiente, que vem das chaves do
-     *  catálogo e não de texto. */
-    readonly node: BaseNode | null;
-    /** O caminho qualificado (`app.router`). */
-    readonly path: string;
-    /** A declaração de fora, ou `null` no topo. */
-    readonly parent: NamespaceDeclaration | null;
-    /** No contexto ambiente (`declare namespace`, e o que está dentro dele). */
-    readonly ambient: boolean;
-    /** O bloco tem valores (o `Instantiated` do `getModuleInstanceState`). */
-    readonly instantiated: boolean;
-    /** Os tipos que ESTE bloco declara (os locais do tsc, com o sentido de tipo). Um tipo e
-     *  um namespace com o mesmo nome convivem, por isso as duas tabelas. */
-    readonly types: ReadonlyMap<string, NamespaceMember>;
-    /** Os namespaces que ESTE bloco declara. */
-    readonly namespaces: ReadonlyMap<string, NamespaceMember>;
-}
-/** As declarações de namespace de uma raiz — o programa, ou o ambiente. */
-interface Namespaces {
-    /** As declarações de cada namespace, pelo caminho, na ordem. */
-    readonly byPath: ReadonlyMap<string, readonly NamespaceDeclaration[]>;
-    /** A declaração de cada nó `TSModuleDeclaration` que está num lugar permitido. */
-    readonly byNode: WeakMap<BaseNode, NamespaceDeclaration>;
-    /** Os aliases escritos num namespace: o nó da declaração do alias → a do namespace. */
-    readonly aliasOwner: WeakMap<BaseNode, NamespaceDeclaration>;
-}
-
-/**
- * Um nível de escopo léxico (nome → `Schema`), sobre o `Scope<T>` genérico do
- * `ast` — a mesma cadeia que o `behavior` usa, com o payload do eixo de tipos.
- */
-type Scope = Scope$1<Schema>;
-/** Cria um escopo raiz (sem pai). */
-declare const rootScope: (vars?: Record<string, Schema>) => Scope;
-/** Estende `parent` com novos bindings, criando um escopo filho. */
-declare const childScope: (parent: Scope, vars: Record<string, Schema>) => Scope;
-/** Resolve `name` subindo a cadeia léxica. `undefined` se não existir. */
-declare const lookup: (scope: Scope, name: string) => Schema | undefined;
-/**
- * Todos os nomes visíveis a partir de `scope`, com shadowing — o binding mais
- * interno vence. É o que alimenta o autocomplete de identificadores. Duas
- * chaves moram no mesmo escopo e não são nomes: a que tem `.` é um caminho
- * estreitado por guard (`narrow`, D13), e a que termina em `#` é o tipo
- * DECLARADO de um binding mutável (D63) — nenhum identificador tem esses
- * caracteres.
- *
- * Um binding do programa tem a chave do SÍMBOLO (`nome@id`, D87), e dois símbolos com
- * o mesmo nome são chaves diferentes: o nome visível é o de fora do `@`, e vale o mais
- * interno. A cadeia vem de dentro para fora, e um refinamento de um símbolo só existe
- * onde o nome dele não está sombreado — então a primeira chave de cada nome é a que ele
- * denota ali.
- */
-declare const visibleNames: (scope: Scope) => Map<string, Schema>;
-/**
- * `name`, visto de `scope`, denota um nome do AMBIENTE (a DI, a lib) — e não um símbolo
- * do programa? É o que o tsc responde olhando a declaração do símbolo resolvido (o
- * `defaultLibrary` do `classifier2020`). A primeira ligação do nome, de dentro para fora, é
- * a que ele denota ali (ver `visibleNames`); `false` quando nada o liga.
- */
-declare function resolvesToEnvironment(scope: Scope, name: string): boolean;
-/**
- * O ambiente injetado pela aplicação — a fronteira de tipos do sistema.
- * `scope` é a raiz da DI; `types` resolve tipos nomeados em anotações.
- */
-/**
- * O ambiente é **só tipos** (a fronteira da DI). Capability — o que pode ser
- * programado — é ortogonal e mora no `CapabilityProfile` (`@tslite/capability`),
- * passado ao `check` por `{ profile }`. Não há mais noção de capability no Env.
- */
-interface Env {
-    readonly scope: Scope;
-    readonly types: Readonly<Record<string, Schema>>;
-    /** Type schemes parametrizados (`type Pair<A, B> = …`), expandidos sob demanda. */
-    readonly schemes: Schemes;
-    /**
-     * Acessores **indexados por path literal**: nome → schema-base que ele navega.
-     * Ex.: `get` sobre o schema dos States → `get("hp","value")` tipa como
-     * `discover(base, ["hp","value"])`. É como a fronteira tipa leituras de estado
-     * sem `unknown` (o app declara o shape; o checker indexa). Default: nenhum.
-     */
-    readonly accessors?: Readonly<Record<string, Schema>>;
-    /**
-     * **Asserters** (a fronteira sã): nomes de funções cujo retorno é o **tipo do
-     * schema nomeado** no 1º argumento. Ex.: com `parse` aqui, `parse(User, x)`
-     * tipa como `User` (e em runtime o `@tslite/validate` valida o valor). É o
-     * `parse()` estilo zod: fecha `unknown`/complexidade — o tipo "reseta" limpo
-     * na fronteira, **provado** em runtime (≠ `as`). Default: nenhum.
-     */
-    readonly asserters?: ReadonlySet<string>;
-    /**
-     * **Matchers de props** (o diferencial): nomes de funções que checam, em
-     * edit-time, se um **payload** (saída de um serviço de automação / nocode) é
-     * **compatível com as props de um componente** react-like. Ex.: com
-     * `matchesProps` aqui, `matchesProps(Card, request)` extrai as props de `Card`
-     * (`(props) => Element`, agnóstico ao framework — Element é `apply` opaco) e
-     * verifica `request ≤ props` (campos a mais no request são OK; faltar/tipo-errado
-     * em prop obrigatória → diagnóstico `props-mismatch`). Retorna `boolean`. Default:
-     * nenhum.
-     */
-    readonly matchers?: ReadonlySet<string>;
-    /**
-     * **Módulos** (a borda DI NOMEADA): especificador → o `object` Schema dos
-     * exports daquele módulo (`{ map: fn, filter: fn, …, default: … }`). É o D3
-     * estendido a módulos: `import { map } from "@x/ops"` liga `map` ao
-     * `modules["@x/ops"].props.map`. O checker **não resolve** o módulo (sem file
-     * system) — consome o tipo já provido; a *resolução* (qual módulo é o
-     * especificador) é da app (Proposal 005). Default: nenhum.
-     */
-    readonly modules?: Readonly<Record<string, Schema>>;
-    /**
-     * Os aliases da **lib padrão** (`Partial`, `Pick`, `Record`, `Omit`, `ReturnType`…),
-     * o texto do `lib.es5.d.ts` do tsc 3.9.10 com o corte do TSLite (D79). Ficam ABAIXO
-     * de tudo: um tipo do host ou um alias do programa com o mesmo nome os sombreia.
-     * Vazio com `noLib`.
-     */
-    readonly lib?: Schemes;
-    /**
-     * Os tipos **nominais** que um texto de tipo pode citar pelo nome: o nome e os type
-     * params de cada um. São os `interface` da lib (`Array`, `ReadonlyArray`, `Promise`)
-     * e os que o host declara (`Map`, `Element`…). Um nominal é o `apply` opaco (types
-     * TC2): o texto `Promise<User>` e o construtor `s.apply("Promise", [User])` são o
-     * mesmo tipo, e a aridade é cobrada como a de um alias.
-     */
-    readonly nominals?: Nominals;
-    /**
-     * Os namespaces do ambiente (D83), lidos das chaves de `types` e `schemes`: um tipo com o
-     * nome qualificado (`state.Config`) é o membro `Config` do namespace `state`, como num
-     * `.d.ts` com `declare namespace state { … }`. Os corpos já chegam com os nomes
-     * resolvidos a partir do namespace de cada um — um `Config` no corpo de `state.Result` é
-     * o `state.Config` —, sem o host reescrever nada.
-     */
-    readonly namespaces?: Namespaces;
-}
-/**
- * O que um `Env` tem além das variáveis. Cada campo espelha o de {@link Env}, e
- * todos são opcionais.
- */
-interface EnvOptions {
-    readonly types?: Readonly<Record<string, Schema>>;
-    readonly schemes?: Readonly<Record<string, TypeScheme>>;
-    readonly accessors?: Readonly<Record<string, Schema>>;
-    readonly asserters?: ReadonlySet<string>;
-    readonly matchers?: ReadonlySet<string>;
-    readonly modules?: Readonly<Record<string, Schema>>;
-    /** Os nominais do host, somados aos da lib (ver {@link Env.nominals}). */
-    readonly nominals?: Nominals;
-    /**
-     * Sem a lib padrão — nem os aliases, nem os nominais dela. É o `--noLib` do tsc: os
-     * nomes da lib passam a ser `unknown-name`, como lá.
-     */
-    readonly noLib?: boolean;
-}
-/**
- * Um catálogo (`Record<string, Schema>`) passado no lugar das opções é o erro que a
- * forma antiga convida (`createEnv(vars, types)`), e o TypeScript o aceitaria em
- * silêncio: um tipo com índice de string cabe num objeto de opções todas
- * opcionais. Este tipo o recusa na compilação — `keyof` de um catálogo é `string`.
- */
-type NoCatalog<O> = string extends keyof O ? never : unknown;
-/**
- * Cria um `Env`: as variáveis injetadas (a raiz da DI) e, por nome, o resto —
- * tipos nomeados, type schemes, acessores, asserters, matchers, módulos.
- * Capability é separada (passe um `profile` ao `check`).
- *
- * As opções são NOMEADAS porque a forma posicional já custou um defeito: uma
- * chamada que parava no quarto argumento compilava, e o asserter (o quinto) ficava
- * fora do ambiente — `parseAs` virava `unknown-name` só naquele lugar. Uma chave
- * fora do vocabulário (um catálogo no lugar das opções, um `type` no lugar de
- * `types`) é `invalid-env-options`, na montagem: o `Env` não nasce com uma metade
- * calada.
- */
-declare const createEnv: <O extends EnvOptions = EnvOptions>(vars?: Readonly<Record<string, Schema>>, options?: O & NoCatalog<O>) => Env;
-/** Os erros que a MONTAGEM do ambiente lança (o `check` em si nunca lança — D2). */
-type CheckerErrorCode = "invalid-env-options";
-/** Resolve um tipo nomeado (`type User = …`) declarado no ambiente. */
-declare const resolveNamed: (env: Env, name: string) => Schema | undefined;
-/** Resolve um type scheme (`type Pair<A, B> = …`) declarado no ambiente. */
-declare const resolveScheme: (env: Env, name: string) => TypeScheme | undefined;
-
-type Severity = "error" | "warning";
-type DiagnosticCode = "not-assignable" | "unknown-name" | "not-callable" | "no-such-member" | "not-object" | "possibly-nullish" | "unknown-value" | "const-needs-init" | "cannot-redeclare" | "circular-type-alias" | "circular-type-annotation" | "unknown-module" | "not-a-schema" | "type-as-value" | "asserter-needs-name" | "shadows-schema" | "missing-argument" | "excess-argument" | "excess-property" | "spread-argument" | "required-after-optional" | "not-iterable" | "not-spreadable" | "overwritten-property" | "implicit-any" | "props-mismatch" | "no-matching-overload" | "constraint-violation" | "wrong-type-argument-count" | "unsupported" | "unused-name" | "assign-to-const" | "for-in-destructuring" | "for-in-not-object" | "readonly-write" | "cast-unsound" | "unprovable-value" | "not-arithmetic-operand" | "operator-not-applicable" | "no-overlap" | "uncalled-function-check" | "not-comparable" | "misplaced-namespace" | "ambient-initializer" | "ambient-statement" | "used-before-assigned" | "used-before-declaration" | "implicit-coercion" | "node-not-allowed" | "name-not-allowed" | "type-feature-not-allowed" | "any-not-allowed" | "narrowing-cast-not-allowed" | "too-deep" | "too-complex-union" | "too-large" | "wrong-result-type";
-/**
- * A **classe** do diagnóstico — espelha a divisão de passes do `tsc` (que nós
- * fundimos num walk só): `semantic` é o que o **binder** do tsc pega (validade do
- * programa, independe de tipos — nome inexistente, redeclaração, módulo, `const`
- * sem init, recurso fora da Linguagem); `type` é o que o **checker** de tipos pega
- * (relações/compatibilidade); `capability` é política/limite (feature gated, caps).
- * O `kind` deriva do `code` (fonte única, mapa `KIND`) — o consumidor (editor/nocode)
- * distingue "isto é programa inválido" de "isto é incompatibilidade de tipo".
- */
-type DiagnosticKind = "semantic" | "type" | "capability";
-/**
- * Uma propriedade que o tipo esperado exige e o valor não tem.
- *
- * O `type` é o ESPERADO — é o que permite a quem corrige inserir um valor
- * plausível (`""`, `0`, `[]`) em vez de um buraco.
- */
-interface MissingProperty {
-    readonly name: string;
-    readonly type: Schema;
-}
-/**
- * Dado ESTRUTURADO do erro, para quem vai **agir** sobre ele.
- *
- * É o campo `data` do LSP, que existe exatamente para isto: levar informação do
- * diagnóstico até o code action, sem que ninguém precise reconstruí-la. Aqui a
- * motivação é concreta — o `notAssignable` já roda o `typeDiff` para escrever a
- * mensagem; jogar o resultado fora obrigaria a camada de correção a recomputá-lo,
- * e ela **não tem como**: o tipo ESPERADO não está no overlay.
- */
-type DiagnosticData = {
-    readonly kind: "missing-properties";
-    /** As propriedades ausentes na RAIZ do valor (as aninhadas ficam de fora). */
-    readonly properties: readonly MissingProperty[];
-} | {
-    /**
-     * `implicit-coercion` (D40): o `+` recusou uma mistura, ou um template
-     * recebeu algo que não converte.
-     *
-     * `textConvertible` diz se o valor culpado **poderia** virar texto (escalar)
-     * ou se é ESTRUTURA. É o que decide o conserto, e por isso vem estruturado em
-     * vez de deduzido da prosa: com escalar o auto-fix propõe template literal;
-     * com estrutura, template não conserta nada — só moveria o erro —, e o
-     * caminho é `stringify`.
-     */
-    readonly kind: "implicit-coercion";
-    readonly textConvertible: boolean;
-};
-/**
- * Outro lugar do programa que explica o diagnóstico — o `DiagnosticRelatedInformation` do
- * tsc (`types.ts`), que o `addRelatedInfo` anexa, e o `relatedInformation` do LSP. O nó é
- * por referência, como o do diagnóstico; a mensagem diz o papel dele ("This spread always
- * overwrites this property.").
- */
-interface DiagnosticRelatedInformation {
-    readonly node: BaseNode;
-    readonly message: string;
-}
-interface Diagnostic {
-    readonly code: DiagnosticCode;
-    /** A classe do diagnóstico (deriva do `code`) — ver {@link DiagnosticKind}. */
-    readonly kind: DiagnosticKind;
-    readonly severity: Severity;
-    /** O nó culpado — identidade por referência. */
-    readonly node: BaseNode;
-    readonly message: string;
-    /** Ver {@link DiagnosticData}. Presente só onde há o que agir. */
-    readonly data?: DiagnosticData;
-    /** Ver {@link DiagnosticRelatedInformation}. Presente só onde o tsc a anexa. */
-    readonly relatedInformation?: readonly DiagnosticRelatedInformation[];
-}
-/**
- * Builder genérico de diagnóstico (severidade configurável). Usado pelos
- * guardrails, que têm seu próprio catálogo de mensagens em `guard`. O `kind`
- * deriva do `code` (mesma fonte única).
- */
-declare const makeDiagnostic: (code: DiagnosticCode, node: BaseNode, message: string, severity?: Severity) => Diagnostic;
-/**
- * Fábricas de diagnósticos. Mensagens no estilo do tsc, com tipos renderizados
- * por `format`.
- */
-declare const diag: {
-    notAssignable: (node: BaseNode, actual: Schema, expected: Schema, schemes?: Schemes) => Diagnostic;
-    unknownName: (node: BaseNode, name: string) => Diagnostic;
-    notCallable: (node: BaseNode, type: Schema) => Diagnostic;
-    noSuchMember: (node: BaseNode, type: Schema, key: string) => Diagnostic;
-    notObject: (node: BaseNode, type: Schema) => Diagnostic;
-    /**
-     * Ler ou chamar através de um valor que pode ser `null`/`undefined` — o
-     * `checkNonNullTypeWithReporter` do tsc (`checker.ts:24098`), que tem uma mensagem por
-     * combinação, e a variante "Cannot invoke" quando o valor é chamado.
-     */
-    possiblyNullish: (node: BaseNode, nullish: {
-        readonly null: boolean;
-        readonly undefined: boolean;
-    }, invoked?: boolean) => Diagnostic;
-    /**
-     * Usar um valor `unknown` como objeto — ler dele, chamá-lo, indexá-lo ou operar
-     * sobre ele. É o mesmo `checkNonNullTypeWithReporter` (`checker.ts:24102`), no ramo
-     * que vem ANTES do nullish e em três linhas:
-     *
-     *     if (strictNullChecks && type.flags & TypeFlags.Unknown) {
-     *         error(node, Diagnostics.Object_is_of_type_unknown);
-     *         return errorType;
-     *     }
-     *
-     * Um código só e uma mensagem só, para os seis usos (o TS2571 da 3.9.10 — o
-     * TS18046 é de versão posterior e não existe na tag).
-     */
-    unknownValue: (node: BaseNode) => Diagnostic;
-    constNeedsInit: (node: BaseNode) => Diagnostic;
-    missingArgument: (node: BaseNode, name: string, expected: Schema) => Diagnostic;
-    notASchema: (node: BaseNode, name: string) => Diagnostic;
-    typeAsValue: (node: BaseNode, name: string) => Diagnostic;
-    asserterNeedsName: (node: BaseNode, asserter: string) => Diagnostic;
-    shadowsSchema: (node: BaseNode, name: string) => Diagnostic;
-    unknownModule: (node: BaseNode, source: string) => Diagnostic;
-    /**
-     * O mesmo nome declarado de novo onde não pode, com o texto de cada mecanismo do tsc
-     * 3.9.10. O conceito é um só, o do `cannot-redeclare` (D2), e o nó é o NOME de cada
-     * declaração acusada.
-     */
-    redeclaration: {
-        /** TS2451: o que está na tabela é variável de escopo de bloco (o `declareSymbol` do
-         *  binder, `binder.ts:476`), em cada declaração. */
-        blockScoped: (node: BaseNode, name: string) => Diagnostic;
-        /** TS2300: o que está na tabela é outra coisa (um parâmetro, um import, um alias, um
-         *  namespace), em cada declaração. */
-        duplicate: (node: BaseNode, name: string) => Diagnostic;
-        /** TS2440: o import fundido com uma declaração local que ocupa o significado do alvo
-         *  dele (o `checkAliasSymbol`, `checker.ts:34279`), no especificador. */
-        importConflict: (node: BaseNode, name: string) => Diagnostic;
-        /** TS2492: o bloco do `catch` declara de novo o binding dele (o `checkTryStatement`,
-         *  `checker.ts:33056`), na declaração do bloco. */
-        catchClause: (node: BaseNode, name: string) => Diagnostic;
-        /** TS2395: declarações do mesmo símbolo, umas exportadas e outras locais, no mesmo
-         *  espaço (o `checkExportsOnMergedDeclarations`, `checker.ts:30401`), em cada uma. */
-        mixedExport: (node: BaseNode, name: string) => Diagnostic;
-    };
-    circularTypeAlias: (node: BaseNode, name: string) => Diagnostic;
-    circularTypeAnnotation: (node: BaseNode, name: string) => Diagnostic;
-    excessArgument: (node: BaseNode, expected: number, got: number) => Diagnostic;
-    /**
-     * A ARIDADE de uma chamada, com o texto do `getArgumentArityError` do tsc
-     * (`checker.ts:25477`): `Expected {range} arguments, but got {got}.` (TS2554), e
-     * `Expected at least {min} arguments, but got {got}.` quando a assinatura tem rest
-     * (TS2555). O `range` é `min` ou `min-max`, e o plural é sempre plural, como lá.
-     *
-     * O CÓDIGO continua dizendo a direção — `missing-argument` quando faltam, e
-     * `excess-argument` quando sobram —, que é informação que o texto do tsc perdeu ao
-     * usar um único TS2554 para os dois. A régua é a D2: o código é o contrato, a mensagem
-     * é prosa.
-     */
-    argumentArity: (node: BaseNode, range: string, got: number, kind: "missing" | "excess", atLeast?: boolean) => Diagnostic;
-    excessProperty: (node: BaseNode, name: string, target: Schema) => Diagnostic;
-    spreadArgument: (node: BaseNode) => Diagnostic;
-    requiredAfterOptional: (node: BaseNode) => Diagnostic;
-    notIterable: (node: BaseNode, type: Schema) => Diagnostic;
-    /**
-     * A fonte não se espalha: o `isValidSpreadType` do tsc (`checker.ts:23342`) a recusa. O
-     * código é o do conceito, par do `not-iterable` do padrão de array; a mensagem diz o caso.
-     */
-    notSpreadable: {
-        /** TS2700: o rest de um padrão de objeto (`{ a, ...rest }`), no elemento do rest
-         *  (`getTypeForBindingElement`, `checker.ts:7439`). D80. */
-        rest: (node: BaseNode) => Diagnostic;
-        /** TS2698: o spread num literal de objeto (`{ ...x }`), no membro `...x`
-         *  (`checkObjectLiteral`, `checker.ts:23254`). */
-        spread: (node: BaseNode) => Diagnostic;
-    };
-    /**
-     * A chave escrita duas vezes num literal de objeto. O tsc a acusa por três mecanismos, e
-     * cada um é um diagnóstico com o texto e o nó dele; o conceito é um só, o do
-     * `cannot-redeclare` (D25).
-     */
-    duplicateKey: {
-        /** TS1117: a chave IDENTIFICADOR repetida, no modo estrito (o `bindObjectLiteralExpression`
-         *  do binder, `binder.ts:2037`), na repetição. */
-        strict: (node: BaseNode) => Diagnostic;
-        /** TS2300: o nome repetido (o `checkGrammarObjectLiteralExpression`), na repetição, com o
-         *  texto do nome como escrito. */
-        identifier: (node: BaseNode, text: string) => Diagnostic;
-        /** TS2718: a chave computada ligada tarde com o nome de uma prop ligada cedo (o
-         *  `lateBindMember`), na chave tardia. */
-        lateBound: (node: BaseNode, name: string) => Diagnostic;
-        /** TS2733: a primeira declaração ligada cedo desse nome, no mesmo `lateBindMember`. */
-        alsoDeclared: (node: BaseNode, name: string) => Diagnostic;
-    };
-    /**
-     * TS2783: a prop escrita num literal de objeto que um spread seguinte sempre sobrescreve,
-     * na prop escrita, com o spread na informação relacionada (TS2785) — o
-     * `checkSpreadPropOverrides` do tsc (`checker.ts:23558`).
-     */
-    overwrittenProperty: (node: BaseNode, name: string, spread: BaseNode) => Diagnostic;
-    /**
-     * O `any` que ninguém escreveu — o `noImplicitAny` do tsc 3.9.10, que faz parte do
-     * `--strict` e está sempre ligado aqui (D81). Um código só, com o texto de cada caso (o
-     * `reportImplicitAny`, `checker.ts:18198`, e os sítios do acesso e do `let` evolving): o
-     * código é o conceito, a mensagem diz qual é o caso (D2), como o `possibly-nullish`.
-     */
-    implicitAny: {
-        /** TS7006, no nome do parâmetro sem anotação e sem contexto. */
-        parameter: (node: BaseNode, name: string) => Diagnostic;
-        /** TS7019, no nome do rest sem anotação e sem contexto. */
-        rest: (node: BaseNode, name: string) => Diagnostic;
-        /** TS7031, em cada folha de um parâmetro-padrão sem anotação nem contexto. */
-        bindingElement: (node: BaseNode, name: string) => Diagnostic;
-        /** TS7034, no nome do `let` evolving que uma closure lê. */
-        evolving: (node: BaseNode, name: string) => Diagnostic;
-        /** TS7005, na leitura desse `let` dentro da closure. */
-        variable: (node: BaseNode, name: string) => Diagnostic;
-        /** TS7053, no acesso inteiro: a chave não indexa o objeto. */
-        index: (node: BaseNode, key: Schema, target: Schema) => Diagnostic;
-        /** TS7015, na chave: o objeto só tem índice numérico, e a chave não é número. */
-        indexNotNumber: (node: BaseNode) => Diagnostic;
-    };
-    /**
-     * A posição de um padrão de array além do comprimento de uma tupla — o TS2493 do tsc, no
-     * nome (`getPropertyTypeForIndexType`, `checker.ts:12886`). O código é o `no-such-member`,
-     * o mesmo do acesso `t[5]` (TC43): a posição é uma propriedade que a tupla não tem.
-     */
-    tupleIndexOutOfRange: (node: BaseNode, tuple: Schema, length: number, index: number) => Diagnostic;
-    propsMismatch: (node: BaseNode, props: Schema, detail: string) => Diagnostic;
-    noMatchingOverload: (node: BaseNode, type: Schema, argTypes: readonly Schema[]) => Diagnostic;
-    /** O argumento de tipo fora do bound — o texto do TS2344 da tag, com a constraint no
-     *  lugar do `{1}`. */
-    constraintViolation: (node: BaseNode, actual: Schema, bound: Schema) => Diagnostic;
-    unsupported: (node: BaseNode, what: string) => Diagnostic;
-    /**
-     * O nome usado antes da declaração dele, com o texto de cada mecanismo do tsc 3.9.10. O
-     * conceito é um só (D2), e o nó é o USO.
-     */
-    usedBeforeDeclaration: {
-        /** TS2448: a variável de escopo de bloco (o `checkResolvedBlockScopedVariable`,
-         *  `checker.ts:2259`), com a declaração na informação relacionada (TS2728). */
-        blockScoped: (node: BaseNode, name: string, declaration: BaseNode) => Diagnostic;
-        /** TS2372: o default de um parâmetro cita o próprio parâmetro (`checker.ts:2009`). */
-        parameterSelf: (node: BaseNode, parameter: string) => Diagnostic;
-        /** TS2373: o default de um parâmetro cita um declarado depois dele (`checker.ts:2013`). */
-        parameterAfter: (node: BaseNode, parameter: string, name: string) => Diagnostic;
-    };
-    /** TS2454: a leitura de uma variável que, por algum caminho, ainda não recebeu valor. */
-    usedBeforeAssigned: (node: BaseNode, name: string) => Diagnostic;
-    /** O namespace (D83), com o texto do tsc em cada um. */
-    namespace: {
-        /** TS2503: o primeiro segmento de um nome qualificado não é namespace nenhum. O
-         *  código é o do nome que não existe, como o TS2304. */
-        notFound: (node: BaseNode, name: string) => Diagnostic;
-        /** TS2694: o namespace não exporta o membro, no segmento do membro. */
-        noExportedMember: (node: BaseNode, namespace: string, member: string) => Diagnostic;
-        /** TS2708: um namespace só de tipos numa posição de valor — o par do TS2693. */
-        asValue: (node: BaseNode, name: string) => Diagnostic;
-        /** TS1235: a declaração fora do topo e de outro namespace, no primeiro token. */
-        misplaced: (node: BaseNode) => Diagnostic;
-    };
-    /** O contexto ambiente (`declare namespace`) só declara — o `checkAmbientInitializer` e o
-     *  `checkGrammarStatementInAmbientContext` do tsc, no nó de lá. */
-    ambient: {
-        /** TS1039: o inicializador que o contexto ambiente não aceita, nele. */
-        initializer: (node: BaseNode) => Diagnostic;
-        /** TS1254: o `const` sem anotação com um inicializador que não é literal, nele. */
-        constInitializer: (node: BaseNode) => Diagnostic;
-        /** TS1036: o statement que não é declaração, uma vez por bloco, no primeiro token. */
-        statement: (node: BaseNode) => Diagnostic;
-    };
-    /**
-     * Argumento de tipo explícito com aridade errada. Assinatura **sem** type params
-     * declarados conta como `expected: 0` — é o que o tsc faz quando
-     * `Signature.typeParameters` é `undefined` (ele nunca infere a lista). Com default, o
-     * esperado é a faixa (`"1-2"`). Mensagem no texto do TS2558, que é sempre plural.
-     */
-    wrongTypeArgumentCount: (node: BaseNode, expected: number | string, got: number) => Diagnostic;
-    /** Nenhuma sobrecarga aceita a aridade, e há uma abaixo e outra acima (≅ TS2743). */
-    noOverloadTypeArgumentCount: (node: BaseNode, got: number, below: number, above: number) => Diagnostic;
-    /** Referência a um alias com aridade errada — as frases do tsc: TS2315 para um
-     *  tipo que não é genérico, TS2314 para o resto (com o intervalo quando há default). */
-    genericTypeArity: (node: BaseNode, name: string, min: number, max: number) => Diagnostic;
-    /**
-     * Binding declarado e nunca lido. **Warning**, não erro: é higiene, não
-     * incompatibilidade — e o consumidor de editor o renderiza APAGADO (marker
-     * `Unnecessary`), não sublinhado. Mensagem no texto do TS6133.
-     */
-    unusedName: (node: BaseNode, name: string) => Diagnostic;
-    /**
-     * Reatribuição de um binding IMUTÁVEL. Não é capability: a capability decide se
-     * `=` existe na Linguagem; se um `const` pode ser reatribuído é outra pergunta, e
-     * a resposta é sempre não (D9 — o piso é `const`). Mensagem no texto do TS2588 /
-     * TS2632 (import). Ver `mutation.ts`.
-     */
-    assignToConst: (node: BaseNode, name: string, kind: "const" | "import" | "not-a-variable") => Diagnostic;
-    /**
-     * As chaves de um `for…in` não cabem no alvo dele (`let n: number; for (n in o)`). É a
-     * relação que falha — o tipo das chaves contra o tipo declarado do alvo —, e por isso
-     * o código é o `not-assignable`; o texto é o do TS2405 (`checkForInStatement`).
-     */
-    forInTarget: (node: BaseNode) => Diagnostic;
-    /** `for ([a] in o)` — o alvo de um `for…in` é uma chave, não se desestrutura. TS2491. */
-    forInDestructuring: (node: BaseNode) => Diagnostic;
-    /** `for (k in n)` com `n` que não é objeto, `any` nem type param — o TS2407 do
-     *  `checkForInStatement` do tsc (`checker.ts:32148`), no que se percorre, com o tipo sem o
-     *  nulo. */
-    forInNotObject: (node: BaseNode, type: Schema) => Diagnostic;
-    /**
-     * Escrita por um ÍNDICE readonly — `readonly T[]` ou `{ readonly [k: string]: V }`. É
-     * a outra metade do modificador: a relação (TC29) diz quem pode ser ATRIBUÍDO a quem;
-     * isto diz quem pode ser ESCRITO. Texto do TS2542, no acesso inteiro. Os três casos de
-     * escrita recusada pelo `readonly` têm um código só (D77): o nó e o texto são os do tsc.
-     */
-    readonlyWrite: (node: BaseNode, target: Schema) => Diagnostic;
-    /** Escrita numa PROPRIEDADE readonly — o TS2540, no nome (`o.a`) ou no argumento
-     *  (`o["a"]`). O acesso vira o tipo-erro: a atribuição não é checada depois. D77. */
-    readonlyProperty: (node: BaseNode, name: string) => Diagnostic;
-    /** `delete` de uma PROPRIEDADE readonly — o TS2704, no operando. D77. */
-    readonlyDelete: (node: BaseNode) => Diagnostic;
-    /**
-     * Cast (`x as T`) entre tipos que não se sobrepõem na régua do tsc (`castOverlaps`:
-     * literal da origem alargado + comparabilidade). Erro, como o TS2352 — o texto é o
-     * dele. Se o cast pode estreitar é outra pergunta, de política: o
-     * `narrowing-cast-not-allowed` do `strict`.
-     */
-    castUnsound: (node: BaseNode, from: Schema, to: Schema) => Diagnostic;
-    /**
-     * `parseAs(T, v)` em que o tipo de `v` não se sobrepõe a `T` na régua do `as`
-     * (`castOverlaps`). O asserter não confere o valor em build — a prova é de
-     * runtime —, mas aqui o build já sabe a resposta: a prova não é incerta, é
-     * impossível, e falhar é a única coisa que ela pode fazer. Erro, com a mesma
-     * severidade do `cast-unsound` (TS2352). Ancorado no VALOR: o tipo escolhido
-     * pode estar certo, e o valor errado é o caso comum.
-     */
-    unprovableValue: (node: BaseNode, value: Schema, target: Schema, name: string) => Diagnostic;
-    /**
-     * Operando de operação aritmética (`*` `-` `/` `%` `**`, bitwise) ou de `++`/`--`
-     * que não é numérico. Espelha TS2362 (esquerdo) / TS2363 (direito) / TS2356 (`++`/`--`).
-     * `bigint`/enum ficam fora do vocabulário do TSL, então a mensagem cita só `number`/`any`.
-     */
-    arithmeticOperand: (node: BaseNode, side: "left" | "right" | "operand") => Diagnostic;
-    /**
-     * `+` (nenhum lado string, nem ambos numéricos) ou relacional (`<` `>` `<=` `>=`)
-     * entre tipos incompatíveis. Espelha TS2365.
-     */
-    operatorNotApplicable: (node: BaseNode, op: string, left: Schema, right: Schema) => Diagnostic;
-    /**
-     * TS2678: o `case` de um `switch` que não é comparável ao discriminante, no `case` — o
-     * `checkTypeComparableTo` do `checkSwitchStatement` do tsc (`checker.ts:32977`). Os tipos
-     * chegam como a comparação os viu: alargados até a base, a menos que os dois sejam
-     * literais. O tsc elabora a relação num objeto (TS2741, TS2740); aqui a mensagem é a do
-     * TS2678, e o código é o contrato (D2).
-     */
-    notComparable: (node: BaseNode, source: Schema, target: Schema) => Diagnostic;
-    /**
-     * TS2774: a condição de um `if` ou de um `?:` é uma função que nunca é falsy, e o ramo
-     * verdadeiro não a usa — o `checkTestingKnownTruthyCallableType` do tsc
-     * (`checker.ts:31963`), na condição.
-     */
-    uncalledFunctionCheck: (node: BaseNode) => Diagnostic;
-    /**
-     * TS2367: uma igualdade entre tipos sem sobreposição, cujo resultado já é sabido — o
-     * `tryGiveBetterPrimaryError` do tsc (`checker.ts`, no `reportOperatorError`): `'false'`
-     * para `===`/`==`, `'true'` para `!==`/`!=`. Os tipos chegam como a mensagem os mostra
-     * (as bases, quando os literais também não se relacionam). Com `missingAwait`, os dois
-     * lados se relacionariam desembrulhando o `Promise`, e a informação relacionada é o
-     * TS2773 (o `errorAndMaybeSuggestAwait`).
-     */
-    noOverlap: (node: BaseNode, op: string, left: Schema, right: Schema, missingAwait: boolean) => Diagnostic;
-    /**
-     * `"x" + n` — o `+` não converte para texto (Proposal 009).
-     *
-     * A mensagem carrega o CONSERTO porque a recusa é deliberada e **diverge do
-     * `tsc`**, que aceita: sem dizer o que fazer, o autor lê como defeito nosso. O
-     * template literal segue coagindo e não alonga o código: `"total: " + n` vira
-     * `` `total: ${n}` ``, do MESMO tamanho — e a partir de duas interpolações o
-     * template encurta.
-     */
-    implicitCoercion: (node: BaseNode, left: Schema, right: Schema, textConvertible: boolean) => Diagnostic;
-    /**
-     * `` `${obj}` `` — o template converte ESCALAR, não estrutura (D40).
-     *
-     * Mesmo código do `+` de propósito: é a mesma decisão vista por outra sintaxe, e
-     * quem filtra por `code` quer as duas juntas. A mensagem é que muda, porque aqui
-     * o conserto é outro (`stringify`, não template).
-     */
-    notTextConvertible: (node: BaseNode, t: Schema) => Diagnostic;
-};
-/**
- * Coletor de diagnósticos — acumula durante o walk, sem `throw`.
- *
- * Guarda cada diagnóstico UMA vez: um segundo com o mesmo nó, o mesmo código, a mesma
- * mensagem e a mesma informação relacionada não entra. É a coleção do tsc
- * (`createDiagnosticCollection`, que insere pelo `insertSorted` e não repete o que o
- * `compareDiagnostics` acha igual — ele compara também o `relatedInformation`), e é o que
- * deixa um argumento ser tipado mais de uma vez — as rodadas da chamada (D53, D81) — sem
- * que o erro de dentro dele saia duas vezes. Dois diagnósticos que só diferem na
- * informação relacionada são dois: `{ a: 1, ...o1, ...o2 }` acusa o `a` uma vez por spread.
- */
-interface DiagnosticSink {
-    /** Diagnósticos coletados, na ordem em que foram reportados, sem repetição. */
-    readonly all: readonly Diagnostic[];
-    /** Quantas vezes o `report` foi chamado, as repetições inclusive: é o que responde "esta
-     *  operação acusou algo?", mesmo quando o que ela acusou já tinha sido acusado. */
-    readonly reported: number;
-    report(d: Diagnostic): void;
-    /** `true` se há ao menos um diagnóstico de severidade `error`. */
-    hasErrors(): boolean;
-}
-/** Cria um coletor vazio. */
-declare function createSink(): DiagnosticSink;
-
-/** Liga a análise de não-usados. Dois eixos independentes, como no tsc. */
-interface UnusedOptions {
-    /** ≅ `noUnusedLocals`: `const` e `import` nunca lidos. */
-    readonly locals?: boolean;
-    /** ≅ `noUnusedParameters`: parâmetros de arrow nunca lidos. */
-    readonly parameters?: boolean;
-}
-/**
- * Coleta os bindings declarados e nunca lidos, como diagnósticos `unused-name`
- * (severidade **warning** — é aviso de higiene, não erro de tipo).
- *
- * **Fora de escopo, de propósito** (limitação declarada, nunca divergência —
- * [[tslite-is-ts-subset]]):
- *
- * - **`type X = …` não-usado** (o TS6196 do tsc). Num TSLite, um alias de `.d.ts`
- *   é contrato ENTRE arquivos por construção — a gramática não tem `export type`
- *   (playground ARCHITECTURE §5), então "não usado neste arquivo" não significa
- *   não usado. Reportar daria falso-positivo em todo `.d.ts`.
- * - **Write-only** (`let x = 1; x = 2` sem leitura — o `noUnusedLocals_writeOnly`
- *   do tsc). Aqui a atribuição conta como leitura, então reportamos MENOS.
- *   Mutação é capability gated (D9), então o caso é raro.
- *
- * **Diferença de MENSAGEM conhecida** (o comportamento bate; a apresentação não —
- * mesmo precedente do D2/D18): o tsc agrupa (`All variables are unused` /
- * `All destructured elements are unused`) quando TODOS os nomes de uma declaração
- * caem. Aqui cada nome sai como um diagnóstico próprio, porque o consumidor é o
- * editor: o fade precisa do range POR NOME, e um diagnóstico na lista inteira não
- * apagaria os nomes individualmente.
- */
-declare function collectUnused(root: BaseNode, opts: UnusedOptions): Diagnostic[];
-
-/** O overlay de tipos: tipo + escopo de cada nó, por referência (ESTree não tem id). */
-type TypeOverlay = WeakMap<BaseNode, {
-    readonly type: Schema;
-    readonly scope: Scope;
-}>;
-interface CheckResult {
-    /** Tipo do nó raiz. */
-    readonly type: Schema;
-    readonly overlay: TypeOverlay;
-    readonly diagnostics: readonly Diagnostic[];
-    /**
-     * Os tipos nomeados resolvíveis (`env.types` ∪ `env.schemes`), já unificados na
-     * forma de scheme. Publicado porque QUEM CONSULTA precisa dele: `discover`
-     * (completions, navegação de membro) só expande um `apply` se receber este
-     * catálogo. Sem publicar, cada consumidor re-derivaria a união — e derivações
-     * paralelas divergem. Num programa sem alias é o catálogo do `Env`, o mesmo objeto em
-     * toda checagem, e congelado (D87).
-     */
-    readonly schemes: Schemes;
-    /**
-     * Os tipos NOMINAIS que um texto de tipo pode citar (`Promise`, `Array`, e os do
-     * host), com os type params de cada um — os que nenhum scheme sombreia. Publicado
-     * pela mesma razão dos `schemes`: é a outra metade do catálogo de nomes de tipo
-     * (D79).
-     */
-    readonly nominals: Nominals;
-}
-/**
- * Tipa `node` no ambiente `env` (a borda da DI: data, states, funções globais).
- * Nunca lança; devolve o overlay e os diagnósticos coletados.
- */
-/** Opções do `check`. */
-interface CheckOptions {
-    /**
-     * Capability profile a enforçar. Quando dado, o `check` roda o guard de capability
-     * (`fromCapability`) além do type-checking e funde os diagnósticos (`node-not-allowed`).
-     * Sem ele, `check` faz **só type-checking** (sem opinar sobre capability).
-     *
-     * Capability **desinstala** features (o que pode existir em runtime — junto do
-     * interpret/codegen); é ortogonal aos `limits`/`resultType` abaixo, que **validam**.
-     */
-    readonly profile?: CapabilityProfile;
-    /**
-     * Limites estruturais (anti-DoS) — validações do checker, cada uma opt-in.
-     * Reportam `too-deep`/`too-large`.
-     */
-    readonly limits?: {
-        /** Profundidade total de aninhamento do AST (qualquer nó). */
-        readonly maxDepth?: number;
-        /** Número total de nós (custo/complexidade). */
-        readonly maxNodes?: number;
-        /** Argumentos por chamada. */
-        readonly maxArgs?: number;
-        /** Aninhamento de funções (função-dentro-de-função). */
-        readonly maxFunctionNesting?: number;
-        /** Aninhamento de chamadas (`f(g(h(x)))`). */
-        readonly maxCallNesting?: number;
-        /** Profundidade de cadeia de membros (`a.b.c.d`). */
-        readonly memberDepth?: number;
-    };
-    /**
-     * Contrato de tipo de retorno: o tipo da expressão-raiz deve ser atribuível a
-     * `resultType`. Reporta `wrong-result-type`. (Ex.: uma condition deve ser `boolean`.)
-     */
-    readonly resultType?: Schema;
-    /**
-     * Análise de bindings declarados e nunca lidos (`unused-name`, **warning**).
-     * Opt-in e com dois eixos independentes, como o `noUnusedLocals` /
-     * `noUnusedParameters` do tsc. Ver [`unused`](./unused.ts) para as isenções.
-     */
-    readonly unused?: UnusedOptions;
-}
-declare function check(node: Node, env: Env, opts?: CheckOptions): CheckResult;
-/**
- * Extrai o **tipo-superfície** de um módulo (o ".d.ts sem arquivo", o dual do import):
- * roda o `check` e projeta os bindings de topo (`const`/`function`) num `object` Schema
- * `{ nome: tipoInferido }`. É como o `tsc` faz o declaration emit — só que aqui o checker
- * **já infere** os tipos (D5/D6 scope-flow), então é uma projeção do overlay, sem Babel
- * nem serialização pra sintaxe. O resultado é exatamente o que outro módulo consome via
- * `env.modules[especificador]` — os dois lados se fecham. (Filtragem por `export` explícito
- * entra quando `export` for implementado; hoje projeta toda a superfície de topo — o caso
- * "inferir o tipo de um algoritmo que não declarou tipos".)
- */
-declare function extractModuleType(program: Node, env: Env, opts?: CheckOptions): {
-    type: ObjectSchema;
-    diagnostics: readonly Diagnostic[];
-};
-/**
- * O DIFERENCIAL — `matchesProps(Component, payload)`: extrai as props do componente
- * react-like (`(props) => Element`; agnóstico ao framework, `Element` é `apply` opaco)
- * e verifica, em edit-time, se o `payload` (saída de um serviço de automação/nocode) é
- * **compatível** com elas: `payload ≤ props`. Campos a MAIS no payload são OK (o
- * componente usa um subconjunto); faltar prop obrigatória ou tipo-errado →
- * `props-mismatch`. Retorna `boolean` (a resposta de runtime). Componente inválido
- * (sem assinatura de função) → não checa.
- */
-/**
- * As props de um componente react-like (`(props) => Element`): a 1ª assinatura, 1º
- * param. É o SSOT da extração — o `matchesProps` (D24, VALIDAÇÃO) e o
- * `componentProps` (AUTORIA, o matchesProps invertido) consomem os dois. Devolve o
- * tipo CRU do param (o `matchesProps` o passa pro `typeDiff`, que resolve).
- */
-declare function componentPropsOf(componentType: Schema, schemes: Schemes): Schema | undefined;
-/**
- * As props do componente registrado como `name` no `env`, para AUTORIA — gerar um
- * form (um campo por prop). É o `matchesProps` **INVERTIDO** (validação → autoria):
- * lê o prop-schema em vez de casar um payload contra ele. Devolve o objeto de props
- * JÁ RESOLVIDO (nome → forma), ou `undefined` se `name` não é `(props) => Element`.
- */
-declare function componentProps(env: Env, name: string): Schema | undefined;
-
-/** Contexto opcional de um guard — o que as regras type-aware leem do `check`. */
-interface GuardContext {
-    readonly overlay?: TypeOverlay;
-    /** Os tipos nomeados do programa: sem eles, uma relação sobre `apply` não expande. */
-    readonly schemes?: Schemes;
-}
-/** Um guard: percorre `root` e devolve os diagnósticos que encontrar. */
-type Guard = (root: BaseNode, ctx: GuardContext) => Diagnostic[];
-/** Um profile é uma composição de guards. */
-type Profile = readonly Guard[];
-/** Roda um profile sobre `root`, concatenando todos os diagnósticos. */
-declare function guard(root: BaseNode, profile: Profile, ctx?: GuardContext): Diagnostic[];
-/** Os kinds que **definem** uma função. */
-declare const FUNCTION_KINDS: readonly ["ArrowFunctionExpression", "FunctionExpression", "FunctionDeclaration"];
-/**
- * O guard de **capability**: percorre `root` e reporta `node-not-allowed` em todo
- * nó proibido por `compiled` — via `nodeViolation`, a **fonte única** de gating
- * compartilhada com o interpret e o codegen. É o que `fromCapability` monta (+ o
- * host allowlist). Garante que os 3 consumidores concordam por construção.
- *
- * Cada nó vai com o pai: é ele que separa o `export` de um membro de namespace
- * (a visibilidade, como o modificador do tsc) do `export` de módulo do teto
- * (capability CP1).
- *
- * O profile diz o que um lugar da aplicação pode EXECUTAR, e o corpo de um namespace que não
- * vira código não executa: o nó do namespace é gateado, e o corpo dele não
- * (`bodyDoesNotRun`). Os guards de autoria de tipo, abaixo, julgam o texto escrito e descem
- * nele.
- */
-declare function capabilityNodes(compiled: CompiledProfile, severity?: Severity): Guard;
-/**
- * O callee de toda chamada deve ser um identificador direto ∈ `names`. É o gate
- * do **host** (a família `host.allow` do `CapabilityProfile`): só as funções
- * liberadas pela DI podem ser chamadas. Montado por `fromCapability`.
- */
-declare function calleeAllowlist(names: readonly string[], severity?: Severity): Guard;
-/**
- * Limita o **aninhamento de um kind** ao longo de qualquer caminho raiz→folha.
- * Ex.: `maxNestingOf(FUNCTION_KINDS, 3)` barra a 4ª função aninhada.
- */
-declare function maxNestingOf(kinds: string | readonly string[], max: number, opts?: {
-    hint?: string;
-    severity?: Severity;
-}): Guard;
-/** Aninhamento de funções (função-dentro-de-função). Padrão: 3 → use um pipe. */
-declare const maxFunctionNesting: (max?: number, severity?: Severity) => Guard;
-/** Aninhamento de chamadas (`f(g(h(x)))`). */
-declare const maxCallNesting: (max: number, severity?: Severity) => Guard;
-/** Profundidade de cadeia de membros (`a.b.c.d`). */
-declare const memberDepth: (max: number, severity?: Severity) => Guard;
-/** Profundidade total de aninhamento do AST (qualquer nó). */
-declare function maxDepth(max: number, severity?: Severity): Guard;
-/** Número total de nós (custo/complexidade). */
-declare function maxNodes(max: number, severity?: Severity): Guard;
-/** Número máximo de argumentos por chamada. */
-declare function maxArgs(max: number, severity?: Severity): Guard;
-/** O tipo da expressão-raiz deve ser atribuível a `expected`. */
-declare function resultType(expected: Schema, schemes?: Schemes, severity?: Severity): Guard;
-
-/** Traduz um `CompiledProfile` (já compilado) num `Profile` de guards. */
-declare function guardsFromCompiled(c: CompiledProfile): Profile;
-/**
- * Compila um `CapabilityProfile` e o traduz num `Profile` de guards. Use com
- * `guard(ast, fromCapability(PRESETS.predicate))`. Assume um profile válido
- * (rode `validateProfile` antes p/ pegar combinações ilegais).
- */
-declare function fromCapability(profile: CapabilityProfile): Profile;
-
-type BinaryOpCategory = "additive" | "arithmetic" | "bitwise" | "relational" | "equality";
-/**
- * O tipo que o operador PRODUZ — como marcador. `"additive"` é o `+` (condicional:
- * `string`|`number`), resolvido no checker. Os demais mapeiam 1:1 num `Schema`.
- */
-type OpResult = "number" | "boolean" | "string" | "additive";
-interface BinaryOpSpec {
-    readonly op: types.BinaryOperator;
-    readonly category: BinaryOpCategory;
-    readonly result: OpResult;
-}
-/** O catálogo dos binários da Linguagem (o `in`/`instanceof` ficam fora: OO/nicho). */
-declare const BINARY_OPS: readonly BinaryOpSpec[];
-/** Lookup O(1) por operador. */
-declare const BINARY_OP: ReadonlyMap<string, BinaryOpSpec>;
-/** O `Schema` que o operador produz — o SSOT do tipo de retorno. `+` (additive) é
- *  condicional e NÃO tem schema fixo: quem chama trata (ver `binaryType` no checker). */
-declare const opResultSchema: (r: Exclude<OpResult, "additive">) => Schema;
-interface UnaryOpSpec {
-    readonly op: types.UnaryOperator;
-    /** O tipo ao qual o resultado é ASSIGNÁVEL (upper bound). O `unaryType` faz
-     *  folding de literal (`-1`→`-1`, `!0`→`true`), então o real é um subtipo disto. */
-    readonly result: "number" | "boolean" | "string" | "undefined";
-}
-declare const UNARY_OPS: readonly UnaryOpSpec[];
-interface LogicalOpSpec {
-    readonly op: types.LogicalOperator;
-}
-/** Os lógicos COMPÕEM o tipo dos operandos (`a && b` refina; não é tipo fixo) —
- *  por isso sem `result`. No slot, um lógico serve quando os operandos servem. */
-declare const LOGICAL_OPS: readonly LogicalOpSpec[];
-/**
- * Os operadores BINÁRIOS cujo resultado é assignável a `target` — a base das
- * sugestões de um slot. Num slot `boolean`: relacionais + igualdades. Num slot
- * `number`: aritméticos/bitwise + `+`. O `+` (additive) serve a slot string OU
- * number. `any`/`unknown` no `target` casa tudo (`subtype` já resolve).
- */
-declare function binaryOpsProducing(target: Schema, schemes?: Schemes): readonly BinaryOpSpec[];
-/** Os operadores UNÁRIOS cujo resultado (upper bound) é assignável a `target`. */
-declare function unaryOpsProducing(target: Schema, schemes?: Schemes): readonly UnaryOpSpec[];
-
-/**
- * Diagnósticos de reatribuição de binding imutável (`const`, `import`).
- *
- * **Sempre roda** — não é opt-in nem gateado por capability, porque `const` é o
- * piso da Linguagem (D9). Um profile que liga mutação libera `let`, não `const`.
- *
- * Roda **ANTES** do walk, e devolve também os alvos recusados: o walk pula a
- * checagem de assignability neles, para não cascatear. É a ordem do tsc — *"to
- * avoid cascading errors check assignability only if 'isReference' check succeeded
- * and no errors were reported"* (`checker.ts:41076`). Sem isso `const c = 1; c = 2`
- * reportaria DOIS erros, sendo que o segundo (`2 ⊄ 1`) é consequência do primeiro.
- */
-declare function collectMutations(root: BaseNode): {
-    readonly diagnostics: readonly Diagnostic[];
-    readonly invalidTargets: WeakSet<BaseNode>;
-};
-
-/** Referência → o `Identifier` que a DECLARA. Por referência, como o overlay. */
-type BindingMap = WeakMap<BaseNode, BaseNode>;
-/**
- * Mapeia cada REFERÊNCIA ao `Identifier` que a declara.
- *
- * É a base de "ir para a definição" (e, no futuro, rename / find-references).
- * **Não** é chamado pelo `check`: é consulta de editor, e o checker roda
- * por-keystroke — quem quer, paga.
- *
- * **Limites** (ambos por ausência de posição, não por preguiça):
- * - **membro** (`obj.price`) não resolve: exigiria a origem do tipo, e `Schema`
- *   não carrega posição;
- * - **nome de tipo em ANOTAÇÃO** (`r: RawViaCep`) não resolve: a anotação é
- *   `Schema` apagável, não nó (E6). O nome de um `type X = …` resolve.
- */
-declare function collectBindings(root: BaseNode): BindingMap;
-
-/** O que um nome denota. */
-type ReferenceSymbol = {
-    readonly kind: "local";
-    /** O `Identifier` que declara — a identidade, por referência. */
-    readonly declaration: BaseNode;
-} | {
-    readonly kind: "environment";
-    /** O caminho a partir da raiz da DI: `["params"]`, `["params", "id"]`. */
-    readonly path: readonly string[];
-};
-/**
- * Onde o nome aparece como SHORTHAND, e portanto nomeia duas coisas ao mesmo tempo
- * — o `prefixText`/`suffixText` do `findRenameLocations` do TypeScript:
- *
- * - `"property"`: o nome é o valor e também a PROPRIEDADE (`{ x }`, ou `const { x
- *   } = o` renomeando o `x` local). A propriedade continua com o nome antigo:
- *   `{ x: x2 }`;
- * - `"binding"`: o nome é a propriedade e também um BINDING (`const { id } =
- *   params`, renomeando o `params.id`). O binding continua com o nome antigo:
- *   `{ id2: id }`;
- * - `"import"`: o nome importado é também o local (`import { a } from "m"`,
- *   renomeando o local): `import { a as a2 }`.
- */
-type Shorthand = "property" | "binding" | "import";
-/** Uma referência a tipo nomeado escrita numa anotação (a `typeRefs` do parser). */
-interface TypeRefSite {
-    readonly name: string;
-    readonly loc: SourceLocation;
-}
-/** Um lugar onde o nome aparece. */
-type Occurrence = {
-    /** O nó cujo texto É o nome: `Identifier`, `JSXIdentifier` ou a chave literal. */
-    readonly site: "node";
-    readonly node: BaseNode;
-    readonly symbol: ReferenceSymbol;
-    /** A declaração do símbolo, e não um uso. */
-    readonly isDeclaration?: true;
-    readonly shorthand?: Shorthand;
-} | {
-    /** Um segmento do `typeof a.b` numa anotação: o nó não tem posição por segmento. */
-    readonly site: "typeQuery";
-    readonly node: BaseNode;
-    readonly segment: number;
-    readonly symbol: ReferenceSymbol;
-} | {
-    /** Um nome de tipo numa anotação, que não é nó (E6 do editor). */
-    readonly site: "typeRef";
-    readonly ref: TypeRefSite;
-    readonly symbol: ReferenceSymbol;
-};
-/** Os dois símbolos são o mesmo? */
-declare function sameSymbol(a: ReferenceSymbol, b: ReferenceSymbol): boolean;
-/**
- * Todas as ocorrências de nome do programa, cada uma com o símbolo que denota.
- *
- * Quem renomeia escolhe o símbolo sob o cursor (`occurrenceAt` do editor) e pega as
- * ocorrências com `sameSymbol`; quem renomeia um caminho do ambiente sem cursor (o
- * host que renomeou a declaração no `Env`) filtra pelo caminho direto.
- */
-declare function collectReferences(root: BaseNode): readonly Occurrence[];
-
-/** Anota uma ligação/parâmetro: `x` → `x: T`. */
-declare const annotate: <N extends BaseNode>(node: N, type: Schema) => N & {
-    typeAnnotation: Schema;
-};
-/** Anota o retorno de uma função: `() => …` → `(): R => …`. */
-declare const annotateReturn: <N extends BaseNode>(fn: N, type: Schema) => N & {
-    returnType: Schema;
-};
-/** Cast `x as T` — `{ expression, typeAnnotation }`; tipa a expressão, resulta `T`. */
-declare const asExpression: (expression: BaseNode, type: Schema) => BaseNode;
-
-/** O tipo inferido de `node`, ou `undefined` se o nó não foi tipado. */
-declare function typeAt(overlay: TypeOverlay, node: BaseNode): Schema | undefined;
-/** O escopo léxico vigente em `node`, ou `undefined` se o nó não foi tipado. */
-declare function scopeAt(overlay: TypeOverlay, node: BaseNode): Scope | undefined;
-/**
- * Completions de **membro**: o que pode seguir a partir do tipo de `node`
- * (ex.: após `obj.` → as props de `obj`; após um array → `[]`). Vazio se o nó
- * não foi tipado ou se o tipo não tem membros navegáveis.
- */
-declare function memberCompletions(overlay: TypeOverlay, node: BaseNode): readonly Completion[];
-/**
- * Completions de **escopo**: os nomes visíveis no contexto de `node` — params,
- * `const`s já declaradas acima e as raízes injetadas pela DI. É o que pode
- * preencher um slot de expressão livre nesse ponto. O mais interno sombreia o
- * externo. Vazio se o nó não foi tipado.
- */
-declare function scopeCompletions(overlay: TypeOverlay, node: BaseNode): readonly Completion[];
-/**
- * O tipo CONTEXTUAL de `ancestors[i]` — o que o nó em torno espera ali.
- *
- * É o `getContextualType` do tsc: **computado sob demanda** a partir da cadeia de
- * ancestrais, não gravado no overlay. O overlay guarda o tipo RESULTANTE de cada
- * nó; o contextual é outra pergunta ("o que caberia aqui?"), e a resposta vive nas
- * anotações do pai — que o parser deixa no nó como `Schema` (`typeAnnotation`,
- * `returnType`).
- *
- * Mora no checker (e não no editor) porque é **semântica**: resolve anotação,
- * consulta o overlay e navega tipo nomeado. O editor faz posição→nó e pergunta.
- *
- * `ancestors` vem do mais interno para o mais externo (`ancestors[i+1]` é o pai de
- * `ancestors[i]`). Devolve `undefined` quando o contexto não determina um tipo —
- * e aí o consumidor não deve inventar.
- */
-declare function contextualTypeAt(ancestors: readonly BaseNode[], i: number, overlay: TypeOverlay, schemes?: Schemes): Schema | undefined;
-/** Os diagnósticos que apontam para `node`. */
-declare function diagnosticsAt(diagnostics: readonly Diagnostic[], node: BaseNode): readonly Diagnostic[];
-
-/** Nó → âncora do domínio. Identidade por referência; `A` é opaca. */
-interface Anchors<A> {
-    /** Carimba o nó e o devolve — para carimbar na própria construção. */
-    stamp<T extends object>(node: T, anchor: A): T;
-    get(node: object): A | undefined;
-}
-declare function createAnchors<A>(): Anchors<A>;
-interface LowerValueOptions<A> {
-    /** A âncora de um filho: chave de objeto ou índice de lista. */
-    readonly child: (anchor: A, key: string | number) => A;
-    /**
-     * O nó de uma ilha. Padrão: `fromExprMarker`, carimbado com a âncora da
-     * posição. Quem tem os nós em memória (com `loc` no texto do campo — os
-     * `islands[].node` do `parseValue` do `@tslite/template`) os entrega aqui, e
-     * o span de um erro dentro da ilha passa a existir.
-     */
-    readonly island?: (marker: object, anchor: A) => Expression;
-}
-/**
- * Um valor JSON com ilhas → uma expressão de nós PRÓPRIOS, carimbados.
- *
- * Por que não entregar o `JsonExpression` ao checker: ele decodifica cada ilha
- * em nós novos para tipá-la, e um erro dentro da ilha aponta um nó que não é do
- * consumidor — o mapa não o conhece, e o diagnóstico cai no fallback. Baixando
- * aqui, o nó é seu, carimbável, e a subida pelos pais alcança.
- *
- * - objeto → `ObjectExpression`; a raiz leva `anchor`; cada chave (um
- *   `Literal`, para representar qualquer chave JSON) e cada `Property` levam
- *   `child(anchor, key)`, e o valor é baixado com a mesma âncora filha. Um
- *   `not-assignable` do objeto inteiro pousa no objeto; um `excess-property`
- *   pousa na chave;
- * - array → `ArrayExpression`, com `child(anchor, i)` por elemento;
- * - ilha → `island(marker, anchor)`;
- * - primitivo → `Literal`.
- */
-declare function lowerValue<A>(value: unknown, anchor: A, anchors: Anchors<A>, opts: LowerValueOptions<A>): Expression;
-interface AnchoredDiagnostic<A> {
-    /** O diagnóstico do checker, com `node` e `data` — intacto. */
-    readonly diagnostic: Diagnostic;
-    readonly anchor: A;
-    /** Offsets no texto da âncora, quando há texto e o nó tem `loc`. */
-    readonly span?: Span;
-}
-interface AnchorDiagnosticsOptions<A> {
-    /** A âncora de quem nada responde. Um diagnóstico sem âncora some. */
-    readonly fallback: A;
-    /** O texto em que a âncora mora — o do campo. Sem ele, não há span. */
-    readonly textOf?: (anchor: A) => string | undefined;
-}
-/**
- * Cada diagnóstico, levado à âncora do nó acusado ou do primeiro pai carimbado.
- *
- * A subida existe por correção, não por economia: o checker ancora um erro no nó
- * mais preciso que tem — o literal de uma chave, o argumento de uma chamada —, e
- * nem todo nó precisa ter sido carimbado (um sub-nó que um builder gerou, um
- * nó sintético). Sem nenhum carimbo no caminho, vale o `fallback`.
- *
- * O `data` do diagnóstico atravessa intacto: é dele que o quick-fix de
- * propriedade faltante vive. O span sai do `loc` do nó acusado, convertido no
- * texto da âncora (`textOf`); sem texto ou sem `loc`, não há span — inventar um
- * seria pior que não ter.
- */
-declare function anchorDiagnostics<A>(root: object, diagnostics: readonly Diagnostic[], anchors: Anchors<A>, opts: AnchorDiagnosticsOptions<A>): AnchoredDiagnostic<A>[];
-/**
- * `loc` do AST → offsets num texto.
- *
- * `loc` ausente → sem span (um nó construído por builder não tem posição, e
- * inventar uma seria pior que não ter); `end` ausente → span de tamanho zero no
- * início; posição fora do texto é presa ao tamanho do texto, e o fim nunca fica
- * antes do início. Para converter muitos `loc` sobre o mesmo texto, use
- * `anchorDiagnostics`, que constrói o mapa de posições uma vez por texto.
- */
-declare function spanOf(text: string, loc: SourceLocation | null | undefined): Span | undefined;
-
-export { type AnchorDiagnosticsOptions, type AnchoredDiagnostic, type Anchors, BINARY_OP, BINARY_OPS, type BinaryOpCategory, type BinaryOpSpec, type BindingMap, type CheckOptions, type CheckResult, type CheckerErrorCode, Completion, type Diagnostic, type DiagnosticCode, type DiagnosticData, type DiagnosticKind, type DiagnosticRelatedInformation, type DiagnosticSink, type Env, type EnvOptions, FUNCTION_KINDS, type Guard, type GuardContext, LOGICAL_OPS, type LogicalOpSpec, type LowerValueOptions, type MissingProperty, type Nominals, ObjectSchema, type Occurrence, type OpResult, type Profile, type ReferenceSymbol, Schema, Schemes, type Scope, type Severity, type Shorthand, type TypeOverlay, type TypeRefSite, TypeScheme, UNARY_OPS, type UnaryOpSpec, type UnusedOptions, VarSchema, anchorDiagnostics, annotate, annotateReturn, asExpression, binaryOpsProducing, calleeAllowlist, capabilityNodes, check, childScope, collectBindings, collectMutations, collectReferences, collectUnused, componentProps, componentPropsOf, contextualTypeAt, createAnchors, createEnv, createSink, diag, diagnosticsAt, extractModuleType, fromCapability, guard, guardsFromCompiled, lookup, lowerValue, makeDiagnostic, maxArgs, maxCallNesting, maxDepth, maxFunctionNesting, maxNestingOf, maxNodes, memberCompletions, memberDepth, opResultSchema, resolveNamed, resolveScheme, resolvesToEnvironment, resultType, rootScope, sameSymbol, scopeAt, scopeCompletions, spanOf, typeAt, unaryOpsProducing, visibleNames };
+export * from "./_namespaces/ts.js";