typescript 7.0.1-rc → 7.0.2

package/NOTICE.txt

@@ -221,7 +221,7 @@ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 
 ---------------------------------------------------------
 
-github.com/go-json-experiment/json v0.0.0-20260601182631-00ed12fed2a6 - BSD-3-Clause
+github.com/go-json-experiment/json v0.0.0-20260623181947-01eb4420fa68 - BSD-3-Clause
 
 
 Copyright 2010 The Go Authors

package/README.md

@@ -1,24 +1,49 @@
-# TypeScript (Native Preview)
+# TypeScript
 
-This package provides a preview build of [the native port of TypeScript](https://devblogs.microsoft.com/typescript/typescript-native-port/).
-Not all features are implemented yet.
+[![CI](https://github.com/microsoft/TypeScript/actions/workflows/ci.yml/badge.svg)](https://github.com/microsoft/TypeScript/actions/workflows/ci.yml)
+[![npm version](https://badge.fury.io/js/typescript.svg)](https://www.npmjs.com/package/typescript)
+[![Downloads](https://img.shields.io/npm/dm/typescript.svg)](https://www.npmjs.com/package/typescript)
+[![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/microsoft/TypeScript/badge)](https://securityscorecards.dev/viewer/?uri=github.com/microsoft/TypeScript)
 
-This package is intended for testing and experimentation.
-It will eventually be replaced by the official TypeScript package.
+[TypeScript](https://www.typescriptlang.org/) is a language for application-scale JavaScript. TypeScript adds optional types to JavaScript that support tools for large-scale JavaScript applications for any browser, for any host, on any OS. TypeScript compiles to readable, standards-based JavaScript. Try it out at the [playground](https://www.typescriptlang.org/play/), and stay up to date via [our blog](https://devblogs.microsoft.com/typescript/) and [Bluesky](https://bsky.app/profile/typescriptlang.org).
 
-## Usage
+Find others who are using TypeScript at [our community page](https://www.typescriptlang.org/community/).
 
-For TypeScript 7.0 RC and later, use `tsc` just like for TypeScript 6.0.
+## Installing
 
-For other builds, use the `tsgo` command just like you would use `tsc`:
+For the latest stable version:
 
-```sh
-npx tsgo --help
+```bash
+npm install -D typescript
 ```
 
-## Issues and Feedback
+For our nightly builds:
 
-The native port of TypeScript is still in progress.
-We expect many gaps, but are seeking experimentation and feedback.
-If you have found differences that are not yet known, we encourage you to leave feedback on [the issue tracker](https://github.com/microsoft/typescript-go/issues).
+```bash
+npm install -D typescript@next
+```
+
+## Contribute
+
+There are many ways to [contribute](https://github.com/microsoft/TypeScript/blob/main/CONTRIBUTING.md) to TypeScript.
+
+* [Submit bugs](https://github.com/microsoft/TypeScript/issues) and help us verify fixes as they are checked in.
+* Review the [source code changes](https://github.com/microsoft/TypeScript/pulls).
+* Engage with other TypeScript users and developers on [Stack Overflow](https://stackoverflow.com/questions/tagged/typescript).
+* Help each other in the [TypeScript Community Discord](https://discord.gg/typescript).
+* Join the [#typescript](https://bsky.app/search?q=%23typescript) discussion on Bluesky.
+* [Contribute bug fixes](https://github.com/microsoft/TypeScript/blob/main/CONTRIBUTING.md).
+
+This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/). For more information see
+the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or contact [opencode@microsoft.com](mailto:opencode@microsoft.com)
+with any additional questions or comments.
+
+## Documentation
+
+* [TypeScript in 5 minutes](https://www.typescriptlang.org/docs/handbook/typescript-in-5-minutes.html)
+* [Programming handbook](https://www.typescriptlang.org/docs/handbook/intro.html)
+* [Homepage](https://www.typescriptlang.org/)
+
+## Roadmap
 
+For details on our planned features and future direction, please refer to our [roadmap](https://github.com/microsoft/TypeScript/wiki/Roadmap).

package/dist/api/async/api.d.ts

@@ -2,6 +2,7 @@
 import { CompletionItemKind } from "#enums/completionItemKind";
 import { DiagnosticCategory } from "#enums/diagnosticCategory";
 import { ElementFlags } from "#enums/elementFlags";
+import { ModuleKind } from "#enums/moduleKind";
 import { NodeBuilderFlags } from "#enums/nodeBuilderFlags";
 import { ObjectFlags } from "#enums/objectFlags";
 import { SignatureFlags } from "#enums/signatureFlags";
@@ -9,17 +10,16 @@ import { SignatureKind } from "#enums/signatureKind";
 import { SymbolFlags } from "#enums/symbolFlags";
 import { TypeFlags } from "#enums/typeFlags";
 import { TypePredicateKind } from "#enums/typePredicateKind";
-import { type Expression, type Identifier, ModifierFlags, type Node, type Path, type SourceFile, type SyntaxKind, type TypeNode } from "../../ast/index.ts";
-import { type ObjectFactories, ObjectRegistry } from "../objectRegistry.ts";
+import { type __String, type Expression, type Identifier, ModifierFlags, type Node, type Path, type SourceFile, type SyntaxKind, type TypeNode } from "../../ast/index.ts";
 import type { APIOptions, LSPConnectionOptions } from "../options.ts";
-import type { ConfigResponse, DocumentIdentifier, DocumentPosition, LSPUpdateSnapshotParams, ProjectResponse, SignatureResponse, SymbolResponse, TypeResponse, UpdateSnapshotParams, UpdateSnapshotResponse } from "../proto.ts";
+import type { CompilerOptions, ConfigResponse, DocumentIdentifier, DocumentPosition, LSPUpdateSnapshotParams, ProjectResponse, SignatureResponse, SourceFileMetadata, SymbolResponse, TypeResponse, UpdateSnapshotParams, UpdateSnapshotResponse } from "../proto.ts";
 import { SourceFileCache } from "../sourceFileCache.ts";
+import type { RequestTiming, TimingAccumulators, TimingInfo } from "../timing.ts";
 import { Client, type ClientSocketOptions, type ClientSpawnOptions } from "./client.ts";
-import type { AssertsIdentifierTypePredicate, AssertsThisTypePredicate, CompletionEntry, CompletionInfo, CompletionOptions, ConditionalType, Diagnostic, FreshableType, IdentifierTypePredicate, IndexedAccessType, IndexInfo, IndexType, InterfaceType, IntersectionType, IntrinsicType, LiteralType, ObjectType, StringMappingType, SubstitutionType, TemplateLiteralType, ThisTypePredicate, TupleType, Type, TypeParameter, TypePredicate, TypePredicateBase, TypeReference, UnionOrIntersectionType, UnionType } from "./types.ts";
-export { CompletionItemKind, DiagnosticCategory, ElementFlags, ModifierFlags, NodeBuilderFlags, ObjectFlags, SignatureFlags, SignatureKind, SymbolFlags, TypeFlags, TypePredicateKind };
-export type { APIOptions, ClientSocketOptions, ClientSpawnOptions, DocumentIdentifier, DocumentPosition, LSPConnectionOptions };
-export type { AssertsIdentifierTypePredicate, AssertsThisTypePredicate, CompletionEntry, CompletionInfo, CompletionOptions, ConditionalType, Diagnostic, FreshableType, IdentifierTypePredicate, IndexedAccessType, IndexInfo, IndexType, InterfaceType, IntersectionType, IntrinsicType, LiteralType, ObjectType, StringMappingType, SubstitutionType, TemplateLiteralType, ThisTypePredicate, TupleType, Type, TypeParameter, TypePredicate, TypePredicateBase, TypeReference, UnionOrIntersectionType, UnionType };
+import type { AssertsIdentifierTypePredicate, AssertsThisTypePredicate, BigIntLiteralType, BooleanLiteralType, CompletionEntry, CompletionInfo, CompletionOptions, ConditionalType, Diagnostic, FreshableType, IdentifierTypePredicate, IndexedAccessType, IndexInfo, IndexType, InterfaceType, IntersectionType, IntrinsicType, JSDocTagInfo, LiteralType, NumberLiteralType, ObjectType, StringLiteralType, StringMappingType, SubstitutionType, TemplateLiteralType, ThisTypePredicate, TupleType, Type, TypeParameter, TypePredicate, TypePredicateBase, TypeReference, UnionOrIntersectionType, UnionType } from "./types.ts";
 export { documentURIToFileName, fileNameToDocumentURI } from "../path.ts";
+export { CompletionItemKind, DiagnosticCategory, ElementFlags, ModifierFlags, ModuleKind, NodeBuilderFlags, ObjectFlags, SignatureFlags, SignatureKind, SymbolFlags, TypeFlags, TypePredicateKind };
+export type { APIOptions, AssertsIdentifierTypePredicate, AssertsThisTypePredicate, BigIntLiteralType, BooleanLiteralType, ClientSocketOptions, ClientSpawnOptions, CompilerOptions, CompletionEntry, CompletionInfo, CompletionOptions, ConditionalType, Diagnostic, DocumentIdentifier, DocumentPosition, FreshableType, IdentifierTypePredicate, IndexedAccessType, IndexInfo, IndexType, InterfaceType, IntersectionType, IntrinsicType, JSDocTagInfo, LiteralType, LSPConnectionOptions, NumberLiteralType, ObjectType, RequestTiming, SourceFileMetadata, StringLiteralType, StringMappingType, SubstitutionType, TemplateLiteralType, ThisTypePredicate, TimingAccumulators, TimingInfo, TupleType, Type, TypeParameter, TypePredicate, TypePredicateBase, TypeReference, UnionOrIntersectionType, UnionType };
 export declare class API<FromLSP extends boolean = false> {
     private client;
     private sourceFileCache;
@@ -28,7 +28,7 @@ export declare class API<FromLSP extends boolean = false> {
     private activeSnapshots;
     private latestSnapshot;
     readonly internal: InternalAPI;
-    constructor(options: APIOptions | LSPConnectionOptions);
+    constructor(options?: APIOptions | LSPConnectionOptions);
     /**
      * Create an API instance from an existing LSP connection's API session.
      * Use this when connecting to an API pipe provided by an LSP server via custom/initializeAPISession.
@@ -39,6 +39,20 @@ export declare class API<FromLSP extends boolean = false> {
     updateSnapshot(params?: FromLSP extends true ? LSPUpdateSnapshotParams : UpdateSnapshotParams): Promise<Snapshot>;
     close(): Promise<void>;
     clearSourceFileCache(): void;
+    /**
+     * Returns a snapshot of collected timing information for requests made
+     * through this API instance: client-measured round-trip latency and bytes
+     * transferred, folded together with the server's own per-request processing
+     * time and an estimated transport overhead (round-trip minus server time).
+     *
+     * Fetching the snapshot issues a lightweight request to the server to
+     * retrieve its timing collection. Collection must be enabled via the
+     * `collectTiming` option; when it is not, the returned snapshot has
+     * `enabled: false` and zeroed totals.
+     */
+    getTimingInfo(): Promise<TimingInfo>;
+    /** Clears all accumulated timing totals and recent-request history, on both the client and the server. */
+    resetTimingInfo(): Promise<void>;
 }
 export declare class InternalAPI {
     private client;
@@ -54,9 +68,9 @@ export declare class Snapshot {
     private projectMap;
     private toPath;
     private client;
-    private objectRegistry;
     private disposed;
     private onDispose;
+    private snapshotRegistry;
     constructor(data: UpdateSnapshotResponse, client: Client, sourceFileCache: SourceFileCache, toPath: (fileName: string) => Path, onDispose: () => void);
     getProjects(): readonly Project[];
     getProject(configFileName: string): Project | undefined;
@@ -66,41 +80,102 @@ export declare class Snapshot {
     isDisposed(): boolean;
     private ensureNotDisposed;
 }
-declare class SnapshotObjectRegistry extends ObjectRegistry<Symbol, TypeObject, Signature> {
+declare class SnapshotObjectRegistry {
+    private readonly symbols;
+    private readonly client;
+    private readonly snapshotId;
+    private readonly resolveProject;
+    constructor(client: Client, snapshotId: number, resolveProject: (projectId: Path) => Project | undefined);
+    /** Resolve a project id (a config file path) to its Project within this snapshot. */
+    getProject(projectId: Path): Project | undefined;
+    getOrCreateSymbol(data: SymbolResponse): Symbol;
+    getSymbol(id: number): Symbol | undefined;
+    clear(): void;
+    fetchSymbol(source: Symbol | Signature | Type, method: string, handle: number | undefined, projectId?: Path): Promise<Symbol>;
+    fetchSymbols(source: Symbol | Signature | Type, method: string, handles?: readonly number[], projectId?: Path): Promise<readonly Symbol[]>;
+}
+declare class ProjectObjectRegistry {
     private client;
     private snapshotId;
-    constructor(factories: ObjectFactories<Symbol, TypeObject, Signature>, client: Client, snapshotId: number);
-    fetchType<T extends Type>(source: Symbol | Signature | Type, method: string, handle: number | undefined): Promise<T>;
+    private project;
+    private snapshotRegistry;
+    private types;
+    private signatures;
+    constructor(client: Client, snapshotId: number, project: Project, snapshotRegistry: SnapshotObjectRegistry);
+    getOrCreateSymbol(data: SymbolResponse): Symbol;
+    getSymbol(id: number): Symbol | undefined;
+    getOrCreateType(data: TypeResponse): TypeObject;
+    getType(id: number): TypeObject | undefined;
+    getOrCreateSignature(data: SignatureResponse): Signature;
+    getSignature(id: number): Signature | undefined;
+    clear(): void;
+    fetchType<T extends Type>(source: Symbol | Signature | Type, method: string, handle: number | false | undefined): Promise<T>;
     fetchSymbol(source: Symbol | Signature | Type, method: string, handle: number | undefined): Promise<Symbol>;
     fetchSignature(source: Symbol | Signature | Type, method: string, handle: number | undefined): Promise<Signature>;
     fetchTypes(source: Symbol | Signature | Type, method: string, handles?: readonly number[]): Promise<readonly Type[]>;
     fetchSymbols(source: Symbol | Signature | Type, method: string, handles?: readonly number[]): Promise<readonly Symbol[]>;
+    fetchBaseTypes(source: Type): Promise<readonly Type[]>;
 }
 export declare class Project {
-    readonly id: string;
+    readonly id: Path;
     readonly configFileName: string;
-    readonly compilerOptions: Record<string, unknown>;
+    readonly compilerOptions: CompilerOptions;
     readonly rootFiles: readonly string[];
     readonly program: Program;
     readonly checker: Checker;
     readonly emitter: Emitter;
     private client;
-    constructor(data: ProjectResponse, snapshotId: number, client: Client, objectRegistry: SnapshotObjectRegistry, sourceFileCache: SourceFileCache, toPath: (fileName: string) => Path);
+    constructor(data: ProjectResponse, snapshotId: number, client: Client, sourceFileCache: SourceFileCache, toPath: (fileName: string) => Path, snapshotRegistry: SnapshotObjectRegistry);
+    dispose(): void;
 }
 export declare class Program {
     private snapshotId;
-    private projectId;
+    private project;
     private client;
     private sourceFileCache;
     private toPath;
     private decoder;
-    constructor(snapshotId: number, projectId: string, client: Client, sourceFileCache: SourceFileCache, toPath: (fileName: string) => Path);
+    private sourceFileMetadataCache;
+    constructor(snapshotId: number, project: Project, client: Client, sourceFileCache: SourceFileCache, toPath: (fileName: string) => Path);
+    getCompilerOptions(): CompilerOptions;
     getSourceFile(file: DocumentIdentifier): Promise<SourceFile | undefined>;
+    getSourceFileNames(): Promise<readonly string[]>;
+    /**
+     * Returns program-stored metadata for the given source file, or `undefined` if the file
+     * is not part of the program. Metadata is fetched lazily per file and cached on this
+     * `Program` instance.
+     */
+    getSourceFileMetadata(fileName: string): Promise<SourceFileMetadata | undefined>;
+    /**
+     * Returns program-stored metadata for the source file at the given path, or `undefined`
+     * if the file is not part of the program. Like {@link getSourceFileMetadata}, but skips
+     * the file name to path conversion. Metadata is fetched lazily per file and cached on
+     * this `Program` instance.
+     */
+    getSourceFileMetadataByPath(path: Path): Promise<SourceFileMetadata | undefined>;
+    private fetchSourceFileMetadata;
+    /**
+     * Returns whether the given source file was loaded as part of an external library
+     * (e.g. a dependency resolved from `node_modules`). The underlying program metadata is
+     * fetched lazily per file and cached on this `Program` instance.
+     */
+    isSourceFileFromExternalLibrary(file: SourceFile): Promise<boolean>;
+    /**
+     * Returns whether the given source file is a default library file (e.g. `lib.d.ts`).
+     * The underlying program metadata is fetched lazily per file and cached on this
+     * `Program` instance.
+     */
+    isSourceFileDefaultLibrary(file: SourceFile): Promise<boolean>;
     /**
      * Get syntactic (parse) diagnostics for a specific file or all files.
      * @param file - Optional file to get diagnostics for. If omitted, returns diagnostics for all files.
      */
     getSyntacticDiagnostics(file?: DocumentIdentifier): Promise<readonly Diagnostic[]>;
+    /**
+     * Get binder diagnostics for a specific file or all files.
+     * @param file - Optional file to get diagnostics for. If omitted, returns diagnostics for all files.
+     */
+    getBindDiagnostics(file?: DocumentIdentifier): Promise<readonly Diagnostic[]>;
     /**
      * Get semantic (type-check) diagnostics for a specific file or all files.
      * @param file - Optional file to get diagnostics for. If omitted, returns diagnostics for all files.
@@ -116,6 +191,14 @@ export declare class Program {
      * @param file - Optional file to get diagnostics for. If omitted, returns diagnostics for all files.
      */
     getDeclarationDiagnostics(file?: DocumentIdentifier): Promise<readonly Diagnostic[]>;
+    /**
+     * Get program-wide diagnostics for the project, including compiler options diagnostics.
+     */
+    getProgramDiagnostics(): Promise<readonly Diagnostic[]>;
+    /**
+     * Get global (non-file-specific) semantic diagnostics for the project.
+     */
+    getGlobalDiagnostics(): Promise<readonly Diagnostic[]>;
     /**
      * Get config file parsing diagnostics for the project.
      */
@@ -123,17 +206,24 @@ export declare class Program {
 }
 export declare class Checker {
     private snapshotId;
-    private projectId;
+    private project;
     private client;
     private objectRegistry;
-    constructor(snapshotId: number, projectId: string, client: Client, objectRegistry: SnapshotObjectRegistry);
+    private wellKnownSymbols;
+    constructor(snapshotId: number, project: Project, client: Client, objectRegistry: ProjectObjectRegistry);
+    dispose(): void;
     getSymbolAtLocation(node: Node): Promise<Symbol | undefined>;
     getSymbolAtLocation(nodes: readonly Node[]): Promise<(Symbol | undefined)[]>;
     getSymbolAtPosition(file: DocumentIdentifier, position: number): Promise<Symbol | undefined>;
     getSymbolAtPosition(file: DocumentIdentifier, positions: readonly number[]): Promise<(Symbol | undefined)[]>;
     getTypeOfSymbol(symbol: Symbol): Promise<Type | undefined>;
     getTypeOfSymbol(symbols: readonly Symbol[]): Promise<(Type | undefined)[]>;
-    getDeclaredTypeOfSymbol(symbol: Symbol): Promise<Type | undefined>;
+    /**
+     * Get the declared type of a symbol. Always returns a type; for symbols whose
+     * declared type cannot be determined the checker yields the error type (use
+     * {@link Type.isErrorType} to detect it).
+     */
+    getDeclaredTypeOfSymbol(symbol: Symbol): Promise<Type>;
     getReferencesToSymbolInFile(file: DocumentIdentifier, symbol: Symbol): Promise<NodeHandle[]>;
     getReferencedSymbolsForNode(node: Node, position: number): Promise<ReferencedSymbolEntry[]>;
     getSignatureUsage(signatureDecl: Node): Promise<SignatureUsage[]>;
@@ -155,7 +245,12 @@ export declare class Checker {
     isArrayLikeType(type: Type): Promise<boolean>;
     isTypeAssignableTo(source: Type, target: Type): Promise<boolean>;
     getShorthandAssignmentValueSymbol(node: Node): Promise<Symbol | undefined>;
-    getTypeOfSymbolAtLocation(symbol: Symbol, location: Node): Promise<Type | undefined>;
+    /**
+     * Get the type of a symbol as narrowed at a specific location. Always returns
+     * a type; for symbols whose type cannot be determined the checker yields the
+     * error type (use {@link Type.isErrorType} to detect it).
+     */
+    getTypeOfSymbolAtLocation(symbol: Symbol, location: Node): Promise<Type>;
     private getIntrinsicType;
     getAnyType(): Promise<Type>;
     getStringType(): Promise<Type>;
@@ -172,19 +267,69 @@ export declare class Checker {
     signatureToSignatureDeclaration(signature: Signature, kind: SyntaxKind, enclosingDeclaration?: Node, flags?: NodeBuilderFlags): Promise<Node | undefined>;
     typeToString(type: Type, enclosingDeclaration?: Node, flags?: number): Promise<string>;
     isContextSensitive(node: Node): Promise<boolean>;
+    isArrayType(type: Type): Promise<boolean>;
+    isTupleType(type: Type): Promise<boolean>;
     getReturnTypeOfSignature(signature: Signature): Promise<Type | undefined>;
     getRestTypeOfSignature(signature: Signature): Promise<Type | undefined>;
     getTypePredicateOfSignature(signature: Signature): Promise<TypePredicate | undefined>;
-    getBaseTypes(type: Type): Promise<readonly Type[]>;
+    /**
+     * Get the base types of a class or interface type. A type with no base types
+     * yields an empty array.
+     */
+    getBaseTypes(type: InterfaceType): Promise<readonly Type[]>;
+    getApparentType(type: Type): Promise<Type | undefined>;
     getPropertiesOfType(type: Type): Promise<readonly Symbol[]>;
     getIndexInfosOfType(type: Type): Promise<readonly IndexInfo[]>;
-    getConstraintOfTypeParameter(type: Type): Promise<Type | undefined>;
-    getTypeArguments(type: Type): Promise<readonly Type[]>;
+    /**
+     * Get the constraint of a type parameter (the `T` in `<U extends T>`), or
+     * undefined if it has none.
+     */
+    getConstraintOfTypeParameter(type: TypeParameter): Promise<Type | undefined>;
+    getBaseConstraintOfType(type: Type): Promise<Type | undefined>;
+    getPropertyOfType(type: Type, name: string): Promise<Symbol | undefined>;
+    getConstantValue(node: Node): Promise<string | number | undefined>;
+    getSignatureFromDeclaration(node: Node): Promise<Signature | undefined>;
+    getExportSpecifierLocalTargetSymbol(node: Node): Promise<Symbol | undefined>;
+    /**
+     * Follow all aliases to get the original symbol. Always returns a symbol; for
+     * an unresolved alias the checker yields the unknown symbol (use
+     * {@link Checker.isUnknownSymbol} to detect it).
+     */
+    getAliasedSymbol(symbol: Symbol): Promise<Symbol>;
+    getImmediateAliasedSymbol(symbol: Symbol): Promise<Symbol | undefined>;
+    /**
+     * Fetch (once, then cache) the handle ids of the per-checker singleton
+     * symbols (unknown, undefined, arguments). These ids are stable for the life
+     * of the project's checker, so identity checks against them are local after
+     * the first call.
+     */
+    private getWellKnownSymbols;
+    /**
+     * Returns `true` if the symbol is the checker's "unknown" symbol (e.g. the
+     * result of {@link Checker.getAliasedSymbol} on an unresolved alias).
+     */
+    isUnknownSymbol(symbol: Symbol): Promise<boolean>;
+    /**
+     * Returns `true` if the symbol is the checker's "undefined" symbol.
+     */
+    isUndefinedSymbol(symbol: Symbol): Promise<boolean>;
+    /**
+     * Returns `true` if the symbol is the checker's "arguments" symbol.
+     */
+    isArgumentsSymbol(symbol: Symbol): Promise<boolean>;
+    getExportsOfModule(symbol: Symbol): Promise<readonly Symbol[]>;
+    getMemberInModuleExports(symbol: Symbol, name: string): Promise<Symbol | undefined>;
+    getJsDocTagsOfSymbol(symbol: Symbol): Promise<readonly JSDocTagInfo[]>;
+    getDocumentationCommentOfSymbol(symbol: Symbol): Promise<string>;
+    /**
+     * Get the type arguments of a type reference (e.g. the `string` in `Array<string>`).
+     */
+    getTypeArguments(type: TypeReference): Promise<readonly Type[]>;
 }
 export interface PrintNodeOptions {
-    preserveSourceNewlines?: boolean;
-    neverAsciiEscape?: boolean;
-    terminateUnterminatedLiterals?: boolean;
+    preserveSourceNewlines?: boolean | undefined;
+    neverAsciiEscape?: boolean | undefined;
+    terminateUnterminatedLiterals?: boolean | undefined;
 }
 export declare class Emitter {
     private client;
@@ -192,22 +337,29 @@ export declare class Emitter {
     printNode(node: Node, options?: PrintNodeOptions): Promise<string>;
 }
 export declare class NodeHandle {
+    /**
+     * The project this handle was produced in, used as the default for {@link resolve}.
+     * Node handles are only meaningful within a project's program, so the producing project
+     * is remembered so callers don't have to pass it explicitly.
+     */
+    private readonly canonicalProject;
     readonly index: number;
     readonly kind: SyntaxKind;
     readonly path: Path;
-    constructor(handle: string);
+    constructor(handle: string, canonicalProject: Project);
     /**
-     * Resolve this handle to the actual AST node by fetching the source file
-     * from the given project and looking up the node by index.
+     * Resolve this handle to the actual AST node by fetching the source file from a project
+     * and looking up the node by index. If no project is passed, the project that produced
+     * the handle is used.
      */
-    resolve(project: Project): Promise<Node | undefined>;
+    resolve(project?: Project): Promise<Node | undefined>;
 }
 /** A symbol definition paired with all of its reference nodes. */
 export interface ReferencedSymbolEntry {
     /** The node handle for the symbol's definition. */
     definition: NodeHandle;
     /** The resolved symbol for the definition, if available. */
-    symbol?: Symbol;
+    symbol?: Symbol | undefined;
     /** The node handles for each reference to the symbol. */
     references: NodeHandle[];
 }
@@ -216,23 +368,45 @@ export interface SignatureUsage {
     /** The node handle for the name reference. */
     name: NodeHandle;
     /** The node handle for the call expression, if the reference is invoked. */
-    call?: NodeHandle;
+    call?: NodeHandle | undefined;
 }
 export declare class Symbol {
     private objectRegistry;
+    /**
+     * The project this symbol was first observed in, used as the default project for
+     * lookups that need a project context (members/exports/parent). Symbols are shared
+     * snapshot-wide, so these lookups can otherwise be ambiguous about which project to use.
+     */
+    private readonly canonicalProject;
     readonly id: number;
+    /** The escaped (`__String`) name, used as the key in member/export tables. */
+    readonly escapedName: __String;
+    /** The display name (escaped underscores removed). */
     readonly name: string;
     readonly flags: SymbolFlags;
     readonly checkFlags: number;
     readonly declarations: readonly NodeHandle[];
     readonly valueDeclaration: NodeHandle | undefined;
-    readonly parent: number;
-    readonly exportSymbol: number;
+    private readonly parent;
+    private readonly exportSymbol;
+    private membersCache;
+    private exportsCache;
     constructor(data: SymbolResponse, objectRegistry: SnapshotObjectRegistry);
     getParent(): Promise<Symbol | undefined>;
-    getMembers(): Promise<readonly Symbol[]>;
-    getExports(): Promise<readonly Symbol[]>;
+    /**
+     * Get this symbol's members keyed by escaped name. The result is cached on
+     * the symbol, so repeated calls do not round-trip to the server.
+     */
+    getMembers(): Promise<ReadonlyMap<__String, Symbol>>;
+    /**
+     * Get this symbol's exports keyed by escaped name. The result is cached on
+     * the symbol, so repeated calls do not round-trip to the server.
+     */
+    getExports(): Promise<ReadonlyMap<__String, Symbol>>;
+    private fetchSymbolTable;
     getExportSymbol(): Promise<Symbol>;
+    getJsDocTags(checker: Checker): Promise<readonly JSDocTagInfo[]>;
+    getDocumentationComment(checker: Checker): Promise<string>;
 }
 declare class TypeObject implements Type {
     private objectRegistry;
@@ -240,7 +414,7 @@ declare class TypeObject implements Type {
     readonly flags: TypeFlags;
     readonly objectFlags: ObjectFlags;
     readonly symbol: number;
-    readonly value: string | number | boolean;
+    readonly value: string | number | boolean | bigint;
     readonly intrinsicName: string;
     readonly isThisType: boolean;
     readonly freshType: number;
@@ -261,16 +435,18 @@ declare class TypeObject implements Type {
     readonly extendsType: number;
     readonly baseType: number;
     readonly substConstraint: number;
-    constructor(data: TypeResponse, objectRegistry: SnapshotObjectRegistry);
+    private trueType;
+    private falseType;
+    constructor(data: TypeResponse, objectRegistry: ProjectObjectRegistry);
     getSymbol(): Promise<Symbol | undefined>;
     getAliasSymbol(): Promise<Symbol | undefined>;
     getTarget(): Promise<Type>;
     getFreshType(): Promise<FreshableType | undefined>;
     getRegularType(): Promise<FreshableType | undefined>;
-    getTypes(): Promise<readonly Type[]>;
-    getTypeParameters(): Promise<readonly Type[]>;
-    getOuterTypeParameters(): Promise<readonly Type[]>;
-    getLocalTypeParameters(): Promise<readonly Type[]>;
+    getTypes(): Promise<readonly Type[] | undefined>;
+    getTypeParameters(): Promise<readonly TypeParameter[]>;
+    getOuterTypeParameters(): Promise<readonly TypeParameter[]>;
+    getLocalTypeParameters(): Promise<readonly TypeParameter[]>;
     getAliasTypeArguments(): Promise<readonly Type[]>;
     getObjectType(): Promise<Type>;
     getIndexType(): Promise<Type>;
@@ -278,7 +454,60 @@ declare class TypeObject implements Type {
     getExtendsType(): Promise<Type>;
     getBaseType(): Promise<Type>;
     getConstraint(): Promise<Type>;
+    getTrueType(): Promise<Type>;
+    getFalseType(): Promise<Type>;
+    /**
+     * Get the base types of this type. Returns `undefined` for any type that is
+     * not a class or interface.
+     */
+    getBaseTypes(): Promise<readonly Type[] | undefined>;
+    isClassOrInterface(): this is InterfaceType;
+    isUnionType(): this is UnionType;
+    isIntersectionType(): this is IntersectionType;
+    isObjectType(): this is ObjectType;
+    isIntrinsicType(): this is IntrinsicType;
+    isErrorType(): boolean;
+    isLiteralType(): this is LiteralType;
+    isStringLiteralType(): this is StringLiteralType;
+    isNumberLiteralType(): this is NumberLiteralType;
+    isBigIntLiteralType(): this is BigIntLiteralType;
+    isBooleanLiteralType(): this is BooleanLiteralType;
+    isTypeReference(): this is TypeReference;
+    isTupleType(): this is TupleType;
+    isIndexType(): this is IndexType;
+    isIndexedAccessType(): this is IndexedAccessType;
+    isConditionalType(): this is ConditionalType;
+    isSubstitutionType(): this is SubstitutionType;
+    isTemplateLiteralType(): this is TemplateLiteralType;
+    isStringMappingType(): this is StringMappingType;
+    isTypeParameter(): this is TypeParameter;
 }
+export declare function isUnionType(type: Type): type is UnionType;
+export declare function isIntersectionType(type: Type): type is IntersectionType;
+export declare function isObjectType(type: Type): type is ObjectType;
+export declare function isClassOrInterfaceType(type: Type): type is InterfaceType;
+export declare function isIntrinsicType(type: Type): type is IntrinsicType;
+/**
+ * Whether this is the error type — the placeholder the checker produces when a
+ * type cannot be determined (e.g. an unresolved reference). It is an intrinsic
+ * type named `"error"` (this covers both the singleton error type and the
+ * per-alias error types manufactured for unresolved type alias references).
+ */
+export declare function isErrorType(type: Type): boolean;
+export declare function isLiteralType(type: Type): type is LiteralType;
+export declare function isStringLiteralType(type: Type): type is StringLiteralType;
+export declare function isNumberLiteralType(type: Type): type is NumberLiteralType;
+export declare function isBigIntLiteralType(type: Type): type is BigIntLiteralType;
+export declare function isBooleanLiteralType(type: Type): type is BooleanLiteralType;
+export declare function isTypeReference(type: Type): type is TypeReference;
+export declare function isTupleType(type: Type): type is TupleType;
+export declare function isIndexType(type: Type): type is IndexType;
+export declare function isIndexedAccessType(type: Type): type is IndexedAccessType;
+export declare function isConditionalType(type: Type): type is ConditionalType;
+export declare function isSubstitutionType(type: Type): type is SubstitutionType;
+export declare function isTemplateLiteralType(type: Type): type is TemplateLiteralType;
+export declare function isStringMappingType(type: Type): type is StringMappingType;
+export declare function isTypeParameter(type: Type): type is TypeParameter;
 export declare class Signature {
     private flags;
     private objectRegistry;
@@ -288,8 +517,8 @@ export declare class Signature {
     readonly parameters: readonly number[];
     readonly thisParameter?: number | undefined;
     readonly target?: number | undefined;
-    constructor(data: SignatureResponse, objectRegistry: SnapshotObjectRegistry);
-    getTypeParameters(): Promise<readonly Type[]>;
+    constructor(data: SignatureResponse, project: Project, objectRegistry: ProjectObjectRegistry);
+    getTypeParameters(): Promise<readonly TypeParameter[]>;
     getParameters(): Promise<readonly Symbol[]>;
     getThisParameter(): Promise<Symbol | undefined>;
     getTarget(): Promise<Signature | undefined>;