typescript 7.1.0-dev.20260827.1 → 7.1.0-dev.20260828.1

package/dist/api/sync/api.d.ts

@@ -1,3 +1,4 @@
+import type { APIRequest as ProtocolRequest, APIResponse as ProtocolResponse } from "../proto.ts";
 import { CheckFlags } from "#enums/checkFlags";
 import { CompletionItemKind } from "#enums/completionItemKind";
 import { DiagnosticCategory } from "#enums/diagnosticCategory";
@@ -14,7 +15,7 @@ import { TypeFormatFlags } from "#enums/typeFormatFlags";
 import { TypePredicateKind } from "#enums/typePredicateKind";
 import { type __String, type Declaration, 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 { APIRequest, APIResponseTuple, CompilerOptions, Diagnostic, DocumentIdentifier, DocumentPosition, LSPUpdateSnapshotParams, ParsedCommandLine, ProjectReference, ProjectResponse, ReadConfigFileResponse, SignaturePropertyMethod, SignatureResponse, SourceFileMetadata, SymbolPropertyMethod, SymbolResponse, SymbolsPropertyMethod, TextEdit, TypeAcquisition, TypePropertyMethod, TypeResponse, TypesPropertyMethod, UpdateSnapshotParams, UpdateSnapshotResponse } from "../proto.ts";
+import type { CompilerOptions, Diagnostic, DocumentIdentifier, DocumentPosition, LSPUpdateSnapshotParams, ParsedCommandLine, ProjectReference, ProjectResponse, ReadConfigFileResponse, SignaturePropertyMethod, SignatureResponse, SourceFileMetadata, SymbolPropertyMethod, SymbolResponse, SymbolsPropertyMethod, TextEdit, TypeAcquisition, TypePropertyMethod, TypeResponse, TypesPropertyMethod, 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";
@@ -33,6 +34,8 @@ export interface TranspileOutput {
     diagnostics?: readonly Diagnostic[];
     sourceMapText?: string;
 }
+export { all } from "./generatorSupport.ts";
+import { type APIRequestGenerator, type ExecutedGeneratorsResults } from "./generatorSupport.ts";
 export declare class API<FromLSP extends boolean = false> implements FormatDiagnosticsHost {
     private client;
     private sourceFileCache;
@@ -48,32 +51,72 @@ export declare class API<FromLSP extends boolean = false> implements FormatDiagn
      * 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.
      */
-    static fromLSPConnection(options: LSPConnectionOptions): API<true>;
-    batchRequests<const Requests extends readonly APIRequest[]>(requests: Requests): {
-        responses: APIResponseTuple<Requests>;
+    static get fromLSPConnection(): {
+        (options: LSPConnectionOptions): API<true>;
+        gen(options: LSPConnectionOptions): Generator<ProtocolRequest, API<true>, ProtocolResponse["result"]>;
     };
-    private ensureInitialized;
+    batch<T extends readonly APIRequestGenerator[]>(...requestGenerators: T): ExecutedGeneratorsResults<T>;
+    private get ensureInitialized();
     getCurrentDirectory(): string;
     getCanonicalFileName(fileName: string): string;
     getNewLine(): string;
-    parseConfigFile(file: DocumentIdentifier): ParsedCommandLine;
-    parseCommandLine(commandLine: readonly string[]): ParsedCommandLine;
-    readConfigFile(file: DocumentIdentifier): ReadConfigFileResponse;
-    parseJsonConfigFileContent(json: any, options: {
-        configDirectory: string;
-        configFileName?: never;
-    } | {
-        configFileName: DocumentIdentifier;
-        configDirectory?: never;
-    }): ParsedCommandLine;
-    transpileModule(input: string, options?: TranspileOptions): TranspileOutput;
-    transpileModuleFromFile(fileName: string, options?: TranspileOptions): TranspileOutput;
-    transpileDeclaration(input: string, options?: TranspileOptions): TranspileOutput;
-    transpileDeclarationFromFile(fileName: string, options?: TranspileOptions): TranspileOutput;
-    updateSnapshot(params?: FromLSP extends true ? LSPUpdateSnapshotParams : UpdateSnapshotParams): Snapshot;
-    close(): void;
+    get parseConfigFile(): {
+        (file: DocumentIdentifier): ParsedCommandLine;
+        gen(file: DocumentIdentifier): Generator<ProtocolRequest, ParsedCommandLine, ProtocolResponse["result"]>;
+    };
+    get parseCommandLine(): {
+        (commandLine: readonly string[]): ParsedCommandLine;
+        gen(commandLine: readonly string[]): Generator<ProtocolRequest, ParsedCommandLine, ProtocolResponse["result"]>;
+    };
+    get readConfigFile(): {
+        (file: DocumentIdentifier): ReadConfigFileResponse;
+        gen(file: DocumentIdentifier): Generator<ProtocolRequest, ReadConfigFileResponse, ProtocolResponse["result"]>;
+    };
+    get parseJsonConfigFileContent(): {
+        (json: any, options: {
+            configDirectory: string;
+            configFileName?: never;
+        } | {
+            configFileName: DocumentIdentifier;
+            configDirectory?: never;
+        }): ParsedCommandLine;
+        gen(json: any, options: {
+            configDirectory: string;
+            configFileName?: never;
+        } | {
+            configFileName: DocumentIdentifier;
+            configDirectory?: never;
+        }): Generator<ProtocolRequest, ParsedCommandLine, ProtocolResponse["result"]>;
+    };
+    get transpileModule(): {
+        (input: string, options?: TranspileOptions): TranspileOutput;
+        gen(input: string, options?: TranspileOptions): Generator<ProtocolRequest, TranspileOutput, ProtocolResponse["result"]>;
+    };
+    get transpileModuleFromFile(): {
+        (fileName: string, options?: TranspileOptions): TranspileOutput;
+        gen(fileName: string, options?: TranspileOptions): Generator<ProtocolRequest, TranspileOutput, ProtocolResponse["result"]>;
+    };
+    get transpileDeclaration(): {
+        (input: string, options?: TranspileOptions): TranspileOutput;
+        gen(input: string, options?: TranspileOptions): Generator<ProtocolRequest, TranspileOutput, ProtocolResponse["result"]>;
+    };
+    get transpileDeclarationFromFile(): {
+        (fileName: string, options?: TranspileOptions): TranspileOutput;
+        gen(fileName: string, options?: TranspileOptions): Generator<ProtocolRequest, TranspileOutput, ProtocolResponse["result"]>;
+    };
+    get updateSnapshot(): {
+        (params?: FromLSP extends true ? LSPUpdateSnapshotParams : UpdateSnapshotParams): Snapshot;
+        gen(params?: FromLSP extends true ? LSPUpdateSnapshotParams : UpdateSnapshotParams): Generator<ProtocolRequest, Snapshot, ProtocolResponse["result"]>;
+    };
+    get close(): {
+        (): void;
+        gen(): Generator<ProtocolRequest, void, ProtocolResponse["result"]>;
+    };
     clearSourceFileCache(): void;
-    runWithTemporaryFileUpdate(baseSnapshot: Snapshot, file: DocumentIdentifier, newText: string, cb: (newSnapshot: Snapshot) => void): void;
+    get runWithTemporaryFileUpdate(): {
+        (baseSnapshot: Snapshot, file: DocumentIdentifier, newText: string, cb: (newSnapshot: Snapshot) => void): void;
+        gen(baseSnapshot: Snapshot, file: DocumentIdentifier, newText: string, cb: (newSnapshot: Snapshot) => void | Generator<ProtocolRequest, void, ProtocolResponse["result"]>): Generator<ProtocolRequest, void, ProtocolResponse["result"]>;
+    };
     /**
      * Returns a snapshot of collected timing information for requests made
      * through this API instance: client-measured round-trip latency and bytes
@@ -85,18 +128,36 @@ export declare class API<FromLSP extends boolean = false> implements FormatDiagn
      * `collectTiming` option; when it is not, the returned snapshot has
      * `enabled: false` and zeroed totals.
      */
-    getTimingInfo(): TimingInfo;
+    get getTimingInfo(): {
+        (): TimingInfo;
+        gen(): Generator<ProtocolRequest, TimingInfo, ProtocolResponse["result"]>;
+    };
     /** Clears all accumulated timing totals and recent-request history, on both the client and the server. */
-    resetTimingInfo(): void;
+    get resetTimingInfo(): {
+        (): void;
+        gen(): Generator<ProtocolRequest, void, ProtocolResponse["result"]>;
+    };
 }
+type EnsureInitialized = (() => void) & {
+    gen(): Generator<ProtocolRequest, void, ProtocolResponse["result"]>;
+};
 export declare class InternalAPI {
     private client;
     private ensureInitialized;
     /** @internal */
-    constructor(client: Client, ensureInitialized: () => void);
-    startCPUProfile(dir: string): void;
-    stopCPUProfile(): string;
-    saveHeapProfile(dir: string): string;
+    constructor(client: Client, ensureInitialized: EnsureInitialized);
+    get startCPUProfile(): {
+        (dir: string): void;
+        gen(dir: string): Generator<ProtocolRequest, void, ProtocolResponse["result"]>;
+    };
+    get stopCPUProfile(): {
+        (): string;
+        gen(): Generator<ProtocolRequest, string, ProtocolResponse["result"]>;
+    };
+    get saveHeapProfile(): {
+        (dir: string): string;
+        gen(dir: string): Generator<ProtocolRequest, string, ProtocolResponse["result"]>;
+    };
 }
 export declare class Snapshot {
     readonly id: number;
@@ -110,9 +171,15 @@ export declare class Snapshot {
     constructor(data: UpdateSnapshotResponse, client: Client, sourceFileCache: SourceFileCache, toPath: (fileName: string) => Path, formatDiagnosticsHost: FormatDiagnosticsHost, onDispose: () => void);
     getProjects(): readonly Project[];
     getProject(configFileName: string): Project | undefined;
-    getDefaultProjectForFile(file: DocumentIdentifier): Project | undefined;
+    get getDefaultProjectForFile(): {
+        (file: DocumentIdentifier): Project | undefined;
+        gen(file: DocumentIdentifier): Generator<ProtocolRequest, Project | undefined, ProtocolResponse["result"]>;
+    };
     [globalThis.Symbol.dispose](): void;
-    dispose(): void;
+    get dispose(): {
+        (): void;
+        gen(): Generator<ProtocolRequest, void, ProtocolResponse["result"]>;
+    };
     isDisposed(): boolean;
     private ensureNotDisposed;
 }
@@ -127,8 +194,14 @@ declare class SnapshotObjectRegistry {
     getOrCreateSymbol(data: SymbolResponse): Symbol;
     getSymbol(id: number): Symbol | undefined;
     clear(): void;
-    fetchSymbol(source: Symbol | Signature | Type, method: SymbolPropertyMethod, handle: number | undefined, projectId: Path): Symbol;
-    fetchSymbols(source: Symbol | Signature | Type, method: SymbolsPropertyMethod, handles: readonly number[] | undefined, projectId: Path): readonly Symbol[];
+    get fetchSymbol(): {
+        (source: Symbol | Signature | Type, method: SymbolPropertyMethod, handle: number | undefined, projectId: Path): Symbol;
+        gen(source: Symbol | Signature | Type, method: SymbolPropertyMethod, handle: number | undefined, projectId: Path): Generator<ProtocolRequest, Symbol, ProtocolResponse["result"]>;
+    };
+    get fetchSymbols(): {
+        (source: Symbol | Signature | Type, method: SymbolsPropertyMethod, handles: readonly number[] | undefined, projectId: Path): readonly Symbol[];
+        gen(source: Symbol | Signature | Type, method: SymbolsPropertyMethod, handles: readonly number[] | undefined, projectId: Path): Generator<ProtocolRequest, readonly Symbol[], ProtocolResponse["result"]>;
+    };
 }
 declare class ProjectObjectRegistry {
     private client;
@@ -145,19 +218,58 @@ declare class ProjectObjectRegistry {
     getOrCreateSignature(data: SignatureResponse): Signature;
     getSignature(id: number): Signature | undefined;
     clear(): void;
-    fetchOptionalType<T extends Type>(source: Symbol | Signature | Type, method: TypePropertyMethod, handle: number | false | undefined): T | undefined;
-    fetchType<T extends Type>(source: Symbol | Signature | Type, method: TypePropertyMethod, handle: number | false | undefined): T;
-    fetchSymbol(source: Symbol | Signature | Type, method: SymbolPropertyMethod, handle: number | undefined): Symbol;
-    fetchSignature(source: Symbol | Signature | Type, method: SignaturePropertyMethod, handle: number | undefined): Signature;
-    fetchTypes(source: Symbol | Signature | Type, method: TypesPropertyMethod, handles?: readonly number[]): readonly Type[];
-    fetchSymbols(source: Symbol | Signature | Type, method: SymbolsPropertyMethod, handles?: readonly number[]): readonly Symbol[];
-    fetchBaseTypes(source: Type): readonly Type[];
-    fetchPropertiesOfType(source: Type): readonly Symbol[];
-    fetchApparentPropertiesOfType(source: Type): readonly Symbol[];
-    fetchPropertyOfType(source: Type, name: string): Symbol | undefined;
-    fetchSignaturesOfType(source: Type, kind: SignatureKind): readonly Signature[];
-    fetchIndexInfosOfType(source: Type): readonly IndexInfo[];
-    fetchTypeParameterAtPosition(source: Signature, pos: number): Type;
+    get fetchOptionalType(): {
+        <T extends Type>(source: Symbol | Signature | Type, method: TypePropertyMethod, handle: number | false | undefined): T | undefined;
+        gen<T extends Type>(source: Symbol | Signature | Type, method: TypePropertyMethod, handle: number | false | undefined): Generator<ProtocolRequest, T | undefined, ProtocolResponse["result"]>;
+    };
+    get fetchType(): {
+        <T extends Type>(source: Symbol | Signature | Type, method: TypePropertyMethod, handle: number | false | undefined): T;
+        gen<T extends Type>(source: Symbol | Signature | Type, method: TypePropertyMethod, handle: number | false | undefined): Generator<ProtocolRequest, T, ProtocolResponse["result"]>;
+    };
+    get fetchSymbol(): {
+        (source: Symbol | Signature | Type, method: SymbolPropertyMethod, handle: number | undefined): Symbol;
+        gen(source: Symbol | Signature | Type, method: SymbolPropertyMethod, handle: number | undefined): Generator<ProtocolRequest, Symbol, ProtocolResponse["result"]>;
+    };
+    get fetchSignature(): {
+        (source: Symbol | Signature | Type, method: SignaturePropertyMethod, handle: number | undefined): Signature;
+        gen(source: Symbol | Signature | Type, method: SignaturePropertyMethod, handle: number | undefined): Generator<ProtocolRequest, Signature, ProtocolResponse["result"]>;
+    };
+    get fetchTypes(): {
+        (source: Symbol | Signature | Type, method: TypesPropertyMethod, handles?: readonly number[]): readonly Type[];
+        gen(source: Symbol | Signature | Type, method: TypesPropertyMethod, handles?: readonly number[]): Generator<ProtocolRequest, readonly Type[], ProtocolResponse["result"]>;
+    };
+    get fetchSymbols(): {
+        (source: Symbol | Signature | Type, method: SymbolsPropertyMethod, handles?: readonly number[]): readonly Symbol[];
+        gen(source: Symbol | Signature | Type, method: SymbolsPropertyMethod, handles?: readonly number[]): Generator<ProtocolRequest, readonly Symbol[], ProtocolResponse["result"]>;
+    };
+    get fetchBaseTypes(): {
+        (source: Type): readonly Type[];
+        gen(source: Type): Generator<ProtocolRequest, readonly Type[], ProtocolResponse["result"]>;
+    };
+    get fetchPropertiesOfType(): {
+        (source: Type): readonly Symbol[];
+        gen(source: Type): Generator<ProtocolRequest, readonly Symbol[], ProtocolResponse["result"]>;
+    };
+    get fetchApparentPropertiesOfType(): {
+        (source: Type): readonly Symbol[];
+        gen(source: Type): Generator<ProtocolRequest, readonly Symbol[], ProtocolResponse["result"]>;
+    };
+    get fetchPropertyOfType(): {
+        (source: Type, name: string): Symbol | undefined;
+        gen(source: Type, name: string): Generator<ProtocolRequest, Symbol | undefined, ProtocolResponse["result"]>;
+    };
+    get fetchSignaturesOfType(): {
+        (source: Type, kind: SignatureKind): readonly Signature[];
+        gen(source: Type, kind: SignatureKind): Generator<ProtocolRequest, readonly Signature[], ProtocolResponse["result"]>;
+    };
+    get fetchIndexInfosOfType(): {
+        (source: Type): readonly IndexInfo[];
+        gen(source: Type): Generator<ProtocolRequest, readonly IndexInfo[], ProtocolResponse["result"]>;
+    };
+    get fetchTypeParameterAtPosition(): {
+        (source: Signature, pos: number): Type;
+        gen(source: Signature, pos: number): Generator<ProtocolRequest, Type, ProtocolResponse["result"]>;
+    };
 }
 export declare class Project {
     readonly id: Path;
@@ -176,9 +288,15 @@ export declare class Project {
     private snapshotId;
     constructor(data: ProjectResponse, snapshotId: number, client: Client, sourceFileCache: SourceFileCache, toPath: (fileName: string) => Path, formatDiagnosticsHost: FormatDiagnosticsHost, snapshotRegistry: SnapshotObjectRegistry);
     /** @deprecated Use `languageService.getImportAdderEdits`. */
-    getImportAdderEdits(file: DocumentIdentifier, actions: readonly APIImportAdderAction[]): readonly TextEdit[];
+    get getImportAdderEdits(): {
+        (file: DocumentIdentifier, actions: readonly APIImportAdderAction[]): readonly TextEdit[];
+        gen(file: DocumentIdentifier, actions: readonly APIImportAdderAction[]): Generator<ProtocolRequest, readonly TextEdit[], ProtocolResponse["result"]>;
+    };
     /** @deprecated Use `languageService.getImportEditsForSymbols`. */
-    getImportEditsForSymbols(file: DocumentIdentifier, symbols: readonly Symbol[], options?: GetImportEditsForSymbolsOptions): readonly TextEdit[];
+    get getImportEditsForSymbols(): {
+        (file: DocumentIdentifier, symbols: readonly Symbol[], options?: GetImportEditsForSymbolsOptions): readonly TextEdit[];
+        gen(file: DocumentIdentifier, symbols: readonly Symbol[], options?: GetImportEditsForSymbolsOptions): Generator<ProtocolRequest, readonly TextEdit[], ProtocolResponse["result"]>;
+    };
     dispose(): void;
 }
 export declare class LanguageService {
@@ -187,11 +305,26 @@ export declare class LanguageService {
     private client;
     private objectRegistry;
     constructor(snapshotId: number, project: Project, client: Client, objectRegistry: ProjectObjectRegistry);
-    getImportAdderEdits(file: DocumentIdentifier, actions: readonly APIImportAdderAction[]): readonly TextEdit[];
-    getImportEditsForSymbols(file: DocumentIdentifier, symbols: readonly Symbol[], options?: GetImportEditsForSymbolsOptions): readonly TextEdit[];
-    getReferencedSymbolsForNode(node: Node, position: number): ReferencedSymbolEntry[];
-    getSignatureUsage(signatureDecl: Node): SignatureUsage[];
-    getCompletionsAtPosition(document: string, position: number, options?: CompletionOptions): CompletionInfo | undefined;
+    get getImportAdderEdits(): {
+        (file: DocumentIdentifier, actions: readonly APIImportAdderAction[]): readonly TextEdit[];
+        gen(file: DocumentIdentifier, actions: readonly APIImportAdderAction[]): Generator<ProtocolRequest, readonly TextEdit[], ProtocolResponse["result"]>;
+    };
+    get getImportEditsForSymbols(): {
+        (file: DocumentIdentifier, symbols: readonly Symbol[], options?: GetImportEditsForSymbolsOptions): readonly TextEdit[];
+        gen(file: DocumentIdentifier, symbols: readonly Symbol[], options?: GetImportEditsForSymbolsOptions): Generator<ProtocolRequest, readonly TextEdit[], ProtocolResponse["result"]>;
+    };
+    get getReferencedSymbolsForNode(): {
+        (node: Node, position: number): ReferencedSymbolEntry[];
+        gen(node: Node, position: number): Generator<ProtocolRequest, ReferencedSymbolEntry[], ProtocolResponse["result"]>;
+    };
+    get getSignatureUsage(): {
+        (signatureDecl: Node): SignatureUsage[];
+        gen(signatureDecl: Node): Generator<ProtocolRequest, SignatureUsage[], ProtocolResponse["result"]>;
+    };
+    get getCompletionsAtPosition(): {
+        (document: string, position: number, options?: CompletionOptions): CompletionInfo | undefined;
+        gen(document: string, position: number, options?: CompletionOptions): Generator<ProtocolRequest, CompletionInfo | undefined, ProtocolResponse["result"]>;
+    };
 }
 export declare class Program implements FormatDiagnosticsHost {
     private snapshotId;
@@ -207,100 +340,160 @@ export declare class Program implements FormatDiagnosticsHost {
     getCanonicalFileName(fileName: string): string;
     getNewLine(): string;
     getCompilerOptions(): CompilerOptions;
-    getSourceFile(file: DocumentIdentifier): SourceFile | undefined;
-    getSourceFileNames(): readonly string[];
+    get getSourceFile(): {
+        (file: DocumentIdentifier): SourceFile | undefined;
+        gen(file: DocumentIdentifier): Generator<ProtocolRequest, SourceFile | undefined, ProtocolResponse["result"]>;
+    };
+    get getSourceFileNames(): {
+        (): readonly string[];
+        gen(): Generator<ProtocolRequest, readonly string[], ProtocolResponse["result"]>;
+    };
     /**
      * 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): SourceFileMetadata | undefined;
+    get getSourceFileMetadata(): {
+        (fileName: string): SourceFileMetadata | undefined;
+        gen(fileName: string): Generator<ProtocolRequest, SourceFileMetadata | undefined, ProtocolResponse["result"]>;
+    };
     /**
      * 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): SourceFileMetadata | undefined;
-    private fetchSourceFileMetadata;
+    get getSourceFileMetadataByPath(): {
+        (path: Path): SourceFileMetadata | undefined;
+        gen(path: Path): Generator<ProtocolRequest, SourceFileMetadata | undefined, ProtocolResponse["result"]>;
+    };
+    private get 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): boolean;
+    get isSourceFileFromExternalLibrary(): {
+        (file: SourceFile): boolean;
+        gen(file: SourceFile): Generator<ProtocolRequest, boolean, ProtocolResponse["result"]>;
+    };
     /**
      * 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): boolean;
+    get isSourceFileDefaultLibrary(): {
+        (file: SourceFile): boolean;
+        gen(file: SourceFile): Generator<ProtocolRequest, boolean, ProtocolResponse["result"]>;
+    };
     /**
      * Get all config source file names associated with this program's project config.
      * Includes the root config file and any extended config files.
      */
-    getConfigFileNames(): readonly string[];
+    get getConfigFileNames(): {
+        (): readonly string[];
+        gen(): Generator<ProtocolRequest, readonly string[], ProtocolResponse["result"]>;
+    };
     /**
      * Get a config source file by file name/URI.
      * This can return the project's root tsconfig file or one of its extended config files.
      */
-    getConfigSourceFile(file: DocumentIdentifier): SourceFile | undefined;
+    get getConfigSourceFile(): {
+        (file: DocumentIdentifier): SourceFile | undefined;
+        gen(file: DocumentIdentifier): Generator<ProtocolRequest, SourceFile | undefined, ProtocolResponse["result"]>;
+    };
     /**
      * Get syntactic (parse) diagnostics for specific files or all files.
      * @param file - Optional file(s) to get diagnostics for. If omitted, returns diagnostics for all files.
      */
-    getSyntacticDiagnostics(file?: DocumentIdentifier | readonly DocumentIdentifier[]): readonly Diagnostic[];
+    get getSyntacticDiagnostics(): {
+        (file?: DocumentIdentifier | readonly DocumentIdentifier[]): readonly Diagnostic[];
+        gen(file?: DocumentIdentifier | readonly DocumentIdentifier[]): Generator<ProtocolRequest, readonly Diagnostic[], ProtocolResponse["result"]>;
+    };
     /**
      * Get binder diagnostics for specific files or all files.
      * @param file - Optional file(s) to get diagnostics for. If omitted, returns diagnostics for all files.
      */
-    getBindDiagnostics(file?: DocumentIdentifier | readonly DocumentIdentifier[]): readonly Diagnostic[];
+    get getBindDiagnostics(): {
+        (file?: DocumentIdentifier | readonly DocumentIdentifier[]): readonly Diagnostic[];
+        gen(file?: DocumentIdentifier | readonly DocumentIdentifier[]): Generator<ProtocolRequest, readonly Diagnostic[], ProtocolResponse["result"]>;
+    };
     /**
      * Get semantic (type-check) diagnostics for specific files or all files.
      * @param file - Optional file(s) to get diagnostics for. If omitted, returns diagnostics for all files.
      */
-    getSemanticDiagnostics(file?: DocumentIdentifier | readonly DocumentIdentifier[]): readonly Diagnostic[];
+    get getSemanticDiagnostics(): {
+        (file?: DocumentIdentifier | readonly DocumentIdentifier[]): readonly Diagnostic[];
+        gen(file?: DocumentIdentifier | readonly DocumentIdentifier[]): Generator<ProtocolRequest, readonly Diagnostic[], ProtocolResponse["result"]>;
+    };
     /**
      * Get suggestion diagnostics for specific files or all files.
      * @param file - Optional file(s) to get diagnostics for. If omitted, returns diagnostics for all files.
      */
-    getSuggestionDiagnostics(file?: DocumentIdentifier | readonly DocumentIdentifier[]): readonly Diagnostic[];
+    get getSuggestionDiagnostics(): {
+        (file?: DocumentIdentifier | readonly DocumentIdentifier[]): readonly Diagnostic[];
+        gen(file?: DocumentIdentifier | readonly DocumentIdentifier[]): Generator<ProtocolRequest, readonly Diagnostic[], ProtocolResponse["result"]>;
+    };
     /**
      * Get declaration emit diagnostics for specific files or all files.
      * @param file - Optional file(s) to get diagnostics for. If omitted, returns diagnostics for all files.
      */
-    getDeclarationDiagnostics(file?: DocumentIdentifier | readonly DocumentIdentifier[]): readonly Diagnostic[];
+    get getDeclarationDiagnostics(): {
+        (file?: DocumentIdentifier | readonly DocumentIdentifier[]): readonly Diagnostic[];
+        gen(file?: DocumentIdentifier | readonly DocumentIdentifier[]): Generator<ProtocolRequest, readonly Diagnostic[], ProtocolResponse["result"]>;
+    };
     /**
      * Get program-wide diagnostics for the project, including compiler options diagnostics.
      */
-    getProgramDiagnostics(): readonly Diagnostic[];
+    get getProgramDiagnostics(): {
+        (): readonly Diagnostic[];
+        gen(): Generator<ProtocolRequest, readonly Diagnostic[], ProtocolResponse["result"]>;
+    };
     /**
      * Get global (non-file-specific) semantic diagnostics for the project.
      */
-    getGlobalDiagnostics(): readonly Diagnostic[];
+    get getGlobalDiagnostics(): {
+        (): readonly Diagnostic[];
+        gen(): Generator<ProtocolRequest, readonly Diagnostic[], ProtocolResponse["result"]>;
+    };
     /**
      * Get config file parsing diagnostics for the project.
      */
-    getConfigFileParsingDiagnostics(): readonly Diagnostic[];
+    get getConfigFileParsingDiagnostics(): {
+        (): readonly Diagnostic[];
+        gen(): Generator<ProtocolRequest, readonly Diagnostic[], ProtocolResponse["result"]>;
+    };
     /**
      * Emits files to the configured filesystem.
      *
      * When the API has a virtual filesystem with a `writeFile` callback, output
      * is written there. Otherwise, the server writes directly to the host filesystem.
      */
-    emit(emitOnly?: EmitOnly): EmitResult;
+    get emit(): {
+        (emitOnly?: EmitOnly): EmitResult;
+        gen(emitOnly?: EmitOnly): Generator<ProtocolRequest, EmitResult, ProtocolResponse["result"]>;
+    };
     /**
      * Emits files and returns their contents without writing to the filesystem.
      */
-    emitToString(emitOnly?: EmitOnly): EmitOutput;
+    get emitToString(): {
+        (emitOnly?: EmitOnly): EmitOutput;
+        gen(emitOnly?: EmitOnly): Generator<ProtocolRequest, EmitOutput, ProtocolResponse["result"]>;
+    };
     /**
      * Gets JavaScript output for selected files regardless of project `noEmit`, `emitDeclarationOnly`, and `noEmitOnError` settings.
      */
-    getJavaScriptEmit(files: readonly DocumentIdentifier[]): EmitOutput;
+    get getJavaScriptEmit(): {
+        (files: readonly DocumentIdentifier[]): EmitOutput;
+        gen(files: readonly DocumentIdentifier[]): Generator<ProtocolRequest, EmitOutput, ProtocolResponse["result"]>;
+    };
     /**
      * Gets declaration output for selected files regardless of project `noEmit`, `declaration`, `emitDeclarationOnly`, and `noEmitOnError` settings.
      */
-    getDeclarationEmit(files: readonly DocumentIdentifier[]): EmitOutput;
+    get getDeclarationEmit(): {
+        (files: readonly DocumentIdentifier[]): EmitOutput;
+        gen(files: readonly DocumentIdentifier[]): Generator<ProtocolRequest, EmitOutput, ProtocolResponse["result"]>;
+    };
 }
 export declare class Checker {
     private snapshotId;
@@ -311,187 +504,432 @@ export declare class Checker {
     private wellKnownSignatures;
     constructor(snapshotId: number, project: Project, client: Client, objectRegistry: ProjectObjectRegistry);
     dispose(): void;
-    getSymbolAtLocation(node: Node): Symbol | undefined;
-    getSymbolAtLocation(nodes: readonly Node[]): (Symbol | undefined)[];
-    getSymbolAtPosition(file: DocumentIdentifier, position: number): Symbol | undefined;
-    getSymbolAtPosition(file: DocumentIdentifier, positions: readonly number[]): (Symbol | undefined)[];
-    getSymbolOfSourceFile(file: DocumentIdentifier): Symbol | undefined;
-    getSymbolOfSourceFile(files: readonly DocumentIdentifier[]): (Symbol | undefined)[];
+    get getSymbolAtLocation(): {
+        (node: Node): Symbol | undefined;
+        (nodes: readonly Node[]): (Symbol | undefined)[];
+        gen(node: Node): Generator<ProtocolRequest, Symbol | undefined, ProtocolResponse["result"]>;
+        gen(nodes: readonly Node[]): Generator<ProtocolRequest, (Symbol | undefined)[], ProtocolResponse["result"]>;
+    };
+    get getSymbolAtPosition(): {
+        (file: DocumentIdentifier, position: number): Symbol | undefined;
+        (file: DocumentIdentifier, positions: readonly number[]): (Symbol | undefined)[];
+        gen(file: DocumentIdentifier, position: number): Generator<ProtocolRequest, Symbol | undefined, ProtocolResponse["result"]>;
+        gen(file: DocumentIdentifier, positions: readonly number[]): Generator<ProtocolRequest, (Symbol | undefined)[], ProtocolResponse["result"]>;
+    };
+    get getSymbolOfSourceFile(): {
+        (file: DocumentIdentifier): Symbol | undefined;
+        (files: readonly DocumentIdentifier[]): (Symbol | undefined)[];
+        gen(file: DocumentIdentifier): Generator<ProtocolRequest, Symbol | undefined, ProtocolResponse["result"]>;
+        gen(files: readonly DocumentIdentifier[]): Generator<ProtocolRequest, (Symbol | undefined)[], ProtocolResponse["result"]>;
+    };
     /**
      * Get the type of a symbol. Always returns a type; for symbols whose type
      * cannot be determined the checker yields the error type (use
      * {@link Type.isErrorType} to detect it).
      */
-    getTypeOfSymbol(symbol: Symbol): Type;
-    getTypeOfSymbol(symbols: readonly Symbol[]): Type[];
+    get getTypeOfSymbol(): {
+        (symbol: Symbol): Type;
+        (symbols: readonly Symbol[]): Type[];
+        gen(symbol: Symbol): Generator<ProtocolRequest, Type, ProtocolResponse["result"]>;
+        gen(symbols: readonly Symbol[]): Generator<ProtocolRequest, Type[], ProtocolResponse["result"]>;
+    };
     /**
      * 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): Type;
-    getReferencesToSymbolInFile(file: DocumentIdentifier, symbol: Symbol): NodeHandle[];
+    get getDeclaredTypeOfSymbol(): {
+        (symbol: Symbol): Type;
+        gen(symbol: Symbol): Generator<ProtocolRequest, Type, ProtocolResponse["result"]>;
+    };
+    /**
+     * Get the type of a symbol, excluding the missing type when
+     * `exactOptionalPropertyTypes: true` is set; for symbols whose
+     * type cannot be determined the checker yields the error type
+     * (use {@link Type.isErrorType} to detect it).
+     */
+    get getNonMissingTypeOfSymbol(): {
+        (symbol: Symbol): Type;
+        gen(symbol: Symbol): Generator<ProtocolRequest, Type, ProtocolResponse["result"]>;
+    };
+    get getReferencesToSymbolInFile(): {
+        (file: DocumentIdentifier, symbol: Symbol): NodeHandle[];
+        gen(file: DocumentIdentifier, symbol: Symbol): Generator<ProtocolRequest, NodeHandle[], ProtocolResponse["result"]>;
+    };
     /** @deprecated Use `project.languageService.getReferencedSymbolsForNode`. */
-    getReferencedSymbolsForNode(node: Node, position: number): ReferencedSymbolEntry[];
+    get getReferencedSymbolsForNode(): {
+        (node: Node, position: number): ReferencedSymbolEntry[];
+        gen(node: Node, position: number): Generator<ProtocolRequest, ReferencedSymbolEntry[], ProtocolResponse["result"]>;
+    };
     /** @deprecated Use `project.languageService.getSignatureUsage`. */
-    getSignatureUsage(signatureDecl: Node): SignatureUsage[];
+    get getSignatureUsage(): {
+        (signatureDecl: Node): SignatureUsage[];
+        gen(signatureDecl: Node): Generator<ProtocolRequest, SignatureUsage[], ProtocolResponse["result"]>;
+    };
     /** @deprecated Use `project.languageService.getCompletionsAtPosition`. */
-    getCompletionsAtPosition(document: string, position: number, options?: CompletionOptions): CompletionInfo | undefined;
+    get getCompletionsAtPosition(): {
+        (document: string, position: number, options?: CompletionOptions): CompletionInfo | undefined;
+        gen(document: string, position: number, options?: CompletionOptions): Generator<ProtocolRequest, CompletionInfo | undefined, ProtocolResponse["result"]>;
+    };
     /**
      * Get the type at a node location. Always returns a type; for nodes whose
      * type cannot be determined the checker yields the error type (use
      * {@link Type.isErrorType} to detect it).
      */
-    getTypeAtLocation(node: Node): Type;
-    getTypeAtLocation(nodes: readonly Node[]): Type[];
-    getSignaturesOfType(type: Type, kind: SignatureKind): readonly Signature[];
+    get getTypeAtLocation(): {
+        (node: Node): Type;
+        (nodes: readonly Node[]): Type[];
+        gen(node: Node): Generator<ProtocolRequest, Type, ProtocolResponse["result"]>;
+        gen(nodes: readonly Node[]): Generator<ProtocolRequest, Type[], ProtocolResponse["result"]>;
+    };
+    get getSignaturesOfType(): {
+        (type: Type, kind: SignatureKind): readonly Signature[];
+        gen(type: Type, kind: SignatureKind): Generator<ProtocolRequest, readonly Signature[], ProtocolResponse["result"]>;
+    };
     /**
      * Get the resolved signature of a call-like expression. Always returns a
      * signature; when a call cannot be resolved the checker yields the unknown
      * signature (use {@link Checker.isUnknownSignature} to detect it).
      */
-    getResolvedSignature(node: Node): Signature;
-    getTypeAtPosition(file: DocumentIdentifier, position: number): Type | undefined;
-    getTypeAtPosition(file: DocumentIdentifier, positions: readonly number[]): (Type | undefined)[];
-    resolveName(name: string, meaning: SymbolFlags, location?: Node | DocumentPosition, excludeGlobals?: boolean): Symbol | undefined;
+    get getResolvedSignature(): {
+        (node: Node): Signature;
+        gen(node: Node): Generator<ProtocolRequest, Signature, ProtocolResponse["result"]>;
+    };
+    get getTypeAtPosition(): {
+        (file: DocumentIdentifier, position: number): Type | undefined;
+        (file: DocumentIdentifier, positions: readonly number[]): (Type | undefined)[];
+        gen(file: DocumentIdentifier, position: number): Generator<ProtocolRequest, Type | undefined, ProtocolResponse["result"]>;
+        gen(file: DocumentIdentifier, positions: readonly number[]): Generator<ProtocolRequest, (Type | undefined)[], ProtocolResponse["result"]>;
+    };
+    get resolveName(): {
+        (name: string, meaning: SymbolFlags, location?: Node | DocumentPosition, excludeGlobals?: boolean): Symbol | undefined;
+        gen(name: string, meaning: SymbolFlags, location?: Node | DocumentPosition, excludeGlobals?: boolean): Generator<ProtocolRequest, Symbol | undefined, ProtocolResponse["result"]>;
+    };
     /**
      * Returns all symbols with the given meaning that are visible at `location`.
      */
-    getSymbolsInScope(location: Node | DocumentPosition, meaning: SymbolFlags): readonly Symbol[];
-    getResolvedSymbol(node: Identifier): Symbol | undefined;
-    getContextualType(node: Expression): Type | undefined;
+    get getSymbolsInScope(): {
+        (location: Node | DocumentPosition, meaning: SymbolFlags): readonly Symbol[];
+        gen(location: Node | DocumentPosition, meaning: SymbolFlags): Generator<ProtocolRequest, readonly Symbol[], ProtocolResponse["result"]>;
+    };
+    get getResolvedSymbol(): {
+        (node: Identifier): Symbol | undefined;
+        gen(node: Identifier): Generator<ProtocolRequest, Symbol | undefined, ProtocolResponse["result"]>;
+    };
+    get getContextualType(): {
+        (node: Expression): Type | undefined;
+        gen(node: Expression): Generator<ProtocolRequest, Type | undefined, ProtocolResponse["result"]>;
+    };
     /** Get the base type of a literal type (e.g. `number` for `42`). Always returns a type. */
-    getBaseTypeOfLiteralType(type: Type): Type;
+    get getBaseTypeOfLiteralType(): {
+        (type: Type): Type;
+        gen(type: Type): Generator<ProtocolRequest, Type, ProtocolResponse["result"]>;
+    };
     /** Get the type with `null` and `undefined` removed. Always returns a type. */
-    getNonNullableType(type: Type): Type;
+    get getNonNullableType(): {
+        (type: Type): Type;
+        gen(type: Type): Generator<ProtocolRequest, Type, ProtocolResponse["result"]>;
+    };
     /**
      * Get the type for a type node. Always returns a type; for type nodes whose
      * type cannot be determined the checker yields the error type (use
      * {@link Type.isErrorType} to detect it).
      */
-    getTypeFromTypeNode(node: TypeNode): Type;
+    get getTypeFromTypeNode(): {
+        (node: TypeNode): Type;
+        gen(node: TypeNode): Generator<ProtocolRequest, Type, ProtocolResponse["result"]>;
+    };
     /** Get the widened type. Always returns a type. */
-    getWidenedType(type: Type): Type;
+    get getWidenedType(): {
+        (type: Type): Type;
+        gen(type: Type): Generator<ProtocolRequest, Type, ProtocolResponse["result"]>;
+    };
     /**
      * Get the type of the parameter at the given index in a signature. Always
      * returns a type; an out-of-range index yields the `any` type.
      */
-    getParameterType(signature: Signature, index: number): Type;
-    isArrayLikeType(type: Type): boolean;
-    isTypeAssignableTo(source: Type, target: Type): boolean;
-    getShorthandAssignmentValueSymbol(node: Node): Symbol | undefined;
+    get getParameterType(): {
+        (signature: Signature, index: number): Type;
+        gen(signature: Signature, index: number): Generator<ProtocolRequest, Type, ProtocolResponse["result"]>;
+    };
+    get isArrayLikeType(): {
+        (type: Type): boolean;
+        gen(type: Type): Generator<ProtocolRequest, boolean, ProtocolResponse["result"]>;
+    };
+    get isTypeAssignableTo(): {
+        (source: Type, target: Type): boolean;
+        gen(source: Type, target: Type): Generator<ProtocolRequest, boolean, ProtocolResponse["result"]>;
+    };
+    get getShorthandAssignmentValueSymbol(): {
+        (node: Node): Symbol | undefined;
+        gen(node: Node): Generator<ProtocolRequest, Symbol | undefined, ProtocolResponse["result"]>;
+    };
     /**
      * 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): Type;
-    private getIntrinsicType;
-    getAnyType(): Type;
-    getStringType(): Type;
-    getNumberType(): Type;
-    getBooleanType(): Type;
-    getVoidType(): Type;
-    getUndefinedType(): Type;
-    getNullType(): Type;
-    getNeverType(): Type;
-    getUnknownType(): Type;
-    getBigIntType(): Type;
-    getESSymbolType(): Type;
-    getNonPrimitiveType(): Type;
-    typeToTypeNode(type: Type, enclosingDeclaration?: Node, flags?: number): TypeNode | undefined;
-    signatureToSignatureDeclaration(signature: Signature, kind: SyntaxKind, enclosingDeclaration?: Node, flags?: NodeBuilderFlags): Node | undefined;
-    typeToString(type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags): string;
-    isContextSensitive(node: Node): boolean;
-    isArrayType(type: Type): boolean;
-    isTupleType(type: Type): boolean;
+    get getTypeOfSymbolAtLocation(): {
+        (symbol: Symbol, location: Node): Type;
+        gen(symbol: Symbol, location: Node): Generator<ProtocolRequest, Type, ProtocolResponse["result"]>;
+    };
+    private get getIntrinsicType();
+    get getAnyType(): {
+        (): Type;
+        gen(): Generator<ProtocolRequest, Type, ProtocolResponse["result"]>;
+    };
+    get getStringType(): {
+        (): Type;
+        gen(): Generator<ProtocolRequest, Type, ProtocolResponse["result"]>;
+    };
+    get getNumberType(): {
+        (): Type;
+        gen(): Generator<ProtocolRequest, Type, ProtocolResponse["result"]>;
+    };
+    get getBooleanType(): {
+        (): Type;
+        gen(): Generator<ProtocolRequest, Type, ProtocolResponse["result"]>;
+    };
+    get getVoidType(): {
+        (): Type;
+        gen(): Generator<ProtocolRequest, Type, ProtocolResponse["result"]>;
+    };
+    get getUndefinedType(): {
+        (): Type;
+        gen(): Generator<ProtocolRequest, Type, ProtocolResponse["result"]>;
+    };
+    get getNullType(): {
+        (): Type;
+        gen(): Generator<ProtocolRequest, Type, ProtocolResponse["result"]>;
+    };
+    get getNeverType(): {
+        (): Type;
+        gen(): Generator<ProtocolRequest, Type, ProtocolResponse["result"]>;
+    };
+    get getUnknownType(): {
+        (): Type;
+        gen(): Generator<ProtocolRequest, Type, ProtocolResponse["result"]>;
+    };
+    get getBigIntType(): {
+        (): Type;
+        gen(): Generator<ProtocolRequest, Type, ProtocolResponse["result"]>;
+    };
+    get getESSymbolType(): {
+        (): Type;
+        gen(): Generator<ProtocolRequest, Type, ProtocolResponse["result"]>;
+    };
+    get getNonPrimitiveType(): {
+        (): Type;
+        gen(): Generator<ProtocolRequest, Type, ProtocolResponse["result"]>;
+    };
+    get typeToTypeNode(): {
+        (type: Type, enclosingDeclaration?: Node, flags?: number): TypeNode | undefined;
+        gen(type: Type, enclosingDeclaration?: Node, flags?: number): Generator<ProtocolRequest, TypeNode | undefined, ProtocolResponse["result"]>;
+    };
+    get signatureToSignatureDeclaration(): {
+        (signature: Signature, kind: SyntaxKind, enclosingDeclaration?: Node, flags?: NodeBuilderFlags): Node | undefined;
+        gen(signature: Signature, kind: SyntaxKind, enclosingDeclaration?: Node, flags?: NodeBuilderFlags): Generator<ProtocolRequest, Node | undefined, ProtocolResponse["result"]>;
+    };
+    get typeToString(): {
+        (type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags): string;
+        gen(type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags): Generator<ProtocolRequest, string, ProtocolResponse["result"]>;
+    };
+    get isContextSensitive(): {
+        (node: Node): boolean;
+        gen(node: Node): Generator<ProtocolRequest, boolean, ProtocolResponse["result"]>;
+    };
+    get isArrayType(): {
+        (type: Type): boolean;
+        gen(type: Type): Generator<ProtocolRequest, boolean, ProtocolResponse["result"]>;
+    };
+    get isTupleType(): {
+        (type: Type): boolean;
+        gen(type: Type): Generator<ProtocolRequest, boolean, ProtocolResponse["result"]>;
+    };
+    /**
+     * The following symbols are considered read-only:
+     * - Properties with a `readonly` modifier
+     * - Variables declared with `const`
+     * - Get accessors without matching set accessors
+     * - Enum members
+     * - `Object.defineProperty` assignments with `writable: false` or no setter
+     * - Unions and intersections of the above
+     */
+    get isReadonlySymbol(): {
+        (symbol: Symbol): boolean;
+        gen(symbol: Symbol): Generator<ProtocolRequest, boolean, ProtocolResponse["result"]>;
+    };
     /** Get the return type of a signature. Always returns a type. */
-    getReturnTypeOfSignature(signature: Signature): Type;
+    get getReturnTypeOfSignature(): {
+        (signature: Signature): Type;
+        gen(signature: Signature): Generator<ProtocolRequest, Type, ProtocolResponse["result"]>;
+    };
     /**
      * Get the rest type of a signature. Always returns a type; a signature with
      * no rest parameter yields the `any` type.
      */
-    getRestTypeOfSignature(signature: Signature): Type;
-    getTypePredicateOfSignature(signature: Signature): TypePredicate | undefined;
+    get getRestTypeOfSignature(): {
+        (signature: Signature): Type;
+        gen(signature: Signature): Generator<ProtocolRequest, Type, ProtocolResponse["result"]>;
+    };
+    get getTypePredicateOfSignature(): {
+        (signature: Signature): TypePredicate | undefined;
+        gen(signature: Signature): Generator<ProtocolRequest, TypePredicate | undefined, ProtocolResponse["result"]>;
+    };
     /**
      * Get the base types of a class or interface type. A type with no base types
      * yields an empty array.
      */
-    getBaseTypes(type: InterfaceType): readonly Type[];
+    get getBaseTypes(): {
+        (type: InterfaceType): readonly Type[];
+        gen(type: InterfaceType): Generator<ProtocolRequest, readonly Type[], ProtocolResponse["result"]>;
+    };
     /** Get the apparent type of a type. Always returns a type. */
-    getApparentType(type: Type): Type;
+    get getApparentType(): {
+        (type: Type): Type;
+        gen(type: Type): Generator<ProtocolRequest, Type, ProtocolResponse["result"]>;
+    };
     /** Get the reduced type of a type. Always returns a type. */
-    getReducedType(type: Type): Type;
-    getPropertiesOfType(type: Type): readonly Symbol[];
-    getIndexInfosOfType(type: Type): readonly IndexInfo[];
+    get getReducedType(): {
+        (type: Type): Type;
+        gen(type: Type): Generator<ProtocolRequest, Type, ProtocolResponse["result"]>;
+    };
+    get getPropertiesOfType(): {
+        (type: Type): readonly Symbol[];
+        gen(type: Type): Generator<ProtocolRequest, readonly Symbol[], ProtocolResponse["result"]>;
+    };
+    get getIndexInfosOfType(): {
+        (type: Type): readonly IndexInfo[];
+        gen(type: Type): Generator<ProtocolRequest, readonly IndexInfo[], ProtocolResponse["result"]>;
+    };
     /**
      * Get the constraint of a type parameter (the `T` in `<U extends T>`), or
      * undefined if it has none.
      */
-    getConstraintOfTypeParameter(type: TypeParameter): Type | undefined;
-    getDefaultFromTypeParameter(type: TypeParameter): Type | undefined;
-    getBaseConstraintOfType(type: Type): Type | undefined;
-    getPropertyOfType(type: Type, name: string): Symbol | undefined;
-    getConstantValue(node: Node): string | number | undefined;
+    get getConstraintOfTypeParameter(): {
+        (type: TypeParameter): Type | undefined;
+        gen(type: TypeParameter): Generator<ProtocolRequest, Type | undefined, ProtocolResponse["result"]>;
+    };
+    get getDefaultFromTypeParameter(): {
+        (type: TypeParameter): Type | undefined;
+        gen(type: TypeParameter): Generator<ProtocolRequest, Type | undefined, ProtocolResponse["result"]>;
+    };
+    get getBaseConstraintOfType(): {
+        (type: Type): Type | undefined;
+        gen(type: Type): Generator<ProtocolRequest, Type | undefined, ProtocolResponse["result"]>;
+    };
+    get getPropertyOfType(): {
+        (type: Type, name: string): Symbol | undefined;
+        gen(type: Type, name: string): Generator<ProtocolRequest, Symbol | undefined, ProtocolResponse["result"]>;
+    };
+    get getConstantValue(): {
+        (node: Node): string | number | undefined;
+        gen(node: Node): Generator<ProtocolRequest, string | number | undefined, ProtocolResponse["result"]>;
+    };
     /** Get the signature of a function-like declaration. Always returns a signature. */
-    getSignatureFromDeclaration(node: Node): Signature;
-    getExportSpecifierLocalTargetSymbol(node: Node): Symbol | undefined;
+    get getSignatureFromDeclaration(): {
+        (node: Node): Signature;
+        gen(node: Node): Generator<ProtocolRequest, Signature, ProtocolResponse["result"]>;
+    };
+    get getExportSpecifierLocalTargetSymbol(): {
+        (node: Node): Symbol | undefined;
+        gen(node: Node): Generator<ProtocolRequest, Symbol | undefined, ProtocolResponse["result"]>;
+    };
     /**
      * 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): Symbol;
+    get getAliasedSymbol(): {
+        (symbol: Symbol): Symbol;
+        gen(symbol: Symbol): Generator<ProtocolRequest, Symbol, ProtocolResponse["result"]>;
+    };
     /**
      * Get the fully qualified name of a symbol, walking up its parent chain
      * (e.g. `"/path/to/module".Namespace.Name`).
      */
-    getFullyQualifiedName(symbol: Symbol): string;
-    getImmediateAliasedSymbol(symbol: Symbol): Symbol | undefined;
+    get getFullyQualifiedName(): {
+        (symbol: Symbol): string;
+        gen(symbol: Symbol): Generator<ProtocolRequest, string, ProtocolResponse["result"]>;
+    };
+    get getImmediateAliasedSymbol(): {
+        (symbol: Symbol): Symbol | undefined;
+        gen(symbol: Symbol): Generator<ProtocolRequest, Symbol | undefined, ProtocolResponse["result"]>;
+    };
     /**
      * Get the target symbol if instantiated, or the provided symbol otherwise.
      */
-    getTargetSymbol(symbol: Symbol): Symbol;
+    get getTargetSymbol(): {
+        (symbol: Symbol): Symbol;
+        gen(symbol: Symbol): Generator<ProtocolRequest, Symbol, ProtocolResponse["result"]>;
+    };
     /**
      * 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;
+    private get 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): boolean;
+    get isUnknownSymbol(): {
+        (symbol: Symbol): boolean;
+        gen(symbol: Symbol): Generator<ProtocolRequest, boolean, ProtocolResponse["result"]>;
+    };
     /**
      * Returns `true` if the symbol is the checker's "undefined" symbol.
      */
-    isUndefinedSymbol(symbol: Symbol): boolean;
+    get isUndefinedSymbol(): {
+        (symbol: Symbol): boolean;
+        gen(symbol: Symbol): Generator<ProtocolRequest, boolean, ProtocolResponse["result"]>;
+    };
     /**
      * Returns `true` if the symbol is the checker's "arguments" symbol.
      */
-    isArgumentsSymbol(symbol: Symbol): boolean;
+    get isArgumentsSymbol(): {
+        (symbol: Symbol): boolean;
+        gen(symbol: Symbol): Generator<ProtocolRequest, boolean, ProtocolResponse["result"]>;
+    };
     /**
      * Fetch (once, then cache) the handle id of the per-checker unknown
      * signature. This id is stable for the life of the project's checker, so
      * identity checks against it are local after the first call.
      */
-    private getWellKnownSignatures;
+    private get getWellKnownSignatures();
     /**
      * Returns `true` if the signature is the checker's "unknown" signature (e.g.
      * the result of {@link Checker.getResolvedSignature} on a call that cannot be
      * resolved).
      */
-    isUnknownSignature(signature: Signature): boolean;
-    getExportsOfModule(symbol: Symbol): readonly Symbol[];
-    getMemberInModuleExports(symbol: Symbol, name: string): Symbol | undefined;
-    getJsDocTagsOfSymbol(symbol: Symbol): readonly JSDocTagInfo[];
-    getDocumentationCommentOfSymbol(symbol: Symbol): string;
+    get isUnknownSignature(): {
+        (signature: Signature): boolean;
+        gen(signature: Signature): Generator<ProtocolRequest, boolean, ProtocolResponse["result"]>;
+    };
+    get getExportsOfModule(): {
+        (symbol: Symbol): readonly Symbol[];
+        gen(symbol: Symbol): Generator<ProtocolRequest, readonly Symbol[], ProtocolResponse["result"]>;
+    };
+    get getMemberInModuleExports(): {
+        (symbol: Symbol, name: string): Symbol | undefined;
+        gen(symbol: Symbol, name: string): Generator<ProtocolRequest, Symbol | undefined, ProtocolResponse["result"]>;
+    };
+    get getJsDocTagsOfSymbol(): {
+        (symbol: Symbol): readonly JSDocTagInfo[];
+        gen(symbol: Symbol): Generator<ProtocolRequest, readonly JSDocTagInfo[], ProtocolResponse["result"]>;
+    };
+    get getDocumentationCommentOfSymbol(): {
+        (symbol: Symbol): string;
+        gen(symbol: Symbol): Generator<ProtocolRequest, string, ProtocolResponse["result"]>;
+    };
     /**
      * Get the type arguments of a type reference (e.g. the `string` in `Array<string>`).
      */
-    getTypeArguments(type: TypeReference): readonly Type[];
+    get getTypeArguments(): {
+        (type: TypeReference): readonly Type[];
+        gen(type: TypeReference): Generator<ProtocolRequest, readonly Type[], ProtocolResponse["result"]>;
+    };
 }
 export interface PrintNodeOptions {
     preserveSourceNewlines?: boolean | undefined;
@@ -501,7 +939,10 @@ export interface PrintNodeOptions {
 export declare class Emitter {
     private client;
     constructor(client: Client);
-    printNode(node: Node, options?: PrintNodeOptions): string;
+    get printNode(): {
+        (node: Node, options?: PrintNodeOptions): string;
+        gen(node: Node, options?: PrintNodeOptions): Generator<ProtocolRequest, string, ProtocolResponse["result"]>;
+    };
 }
 export declare class SnapshotInternalAPI {
     private snapshotId;
@@ -516,7 +957,10 @@ export declare class SnapshotInternalAPI {
      * @param position The UTF-16 code-unit offset in the target file for insertion.
      * @returns The formatted text of the node, indented for the insertion position.
      */
-    formatNodeForInsertion(node: Node, file: DocumentIdentifier, position: number): string;
+    get formatNodeForInsertion(): {
+        (node: Node, file: DocumentIdentifier, position: number): string;
+        gen(node: Node, file: DocumentIdentifier, position: number): Generator<ProtocolRequest, string, ProtocolResponse["result"]>;
+    };
 }
 export declare class NodeHandle<out T extends Node = Node> {
     /**
@@ -534,7 +978,10 @@ export declare class NodeHandle<out T extends Node = Node> {
      * and looking up the node by index. If no project is passed, the project that produced
      * the handle is used.
      */
-    resolve(project?: Project): T | undefined;
+    get resolve(): {
+        (project?: Project): T | undefined;
+        gen(project?: Project): Generator<ProtocolRequest, T | undefined, ProtocolResponse["result"]>;
+    };
 }
 /** A symbol definition paired with all of its reference nodes. */
 export interface ReferencedSymbolEntry {
@@ -574,21 +1021,39 @@ export declare class Symbol {
     private membersCache;
     private exportsCache;
     constructor(data: SymbolResponse, objectRegistry: SnapshotObjectRegistry);
-    getParent(): Symbol | undefined;
+    get getParent(): {
+        (): Symbol | undefined;
+        gen(): Generator<ProtocolRequest, Symbol | undefined, ProtocolResponse["result"]>;
+    };
     /**
      * 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(): ReadonlyMap<__String, Symbol>;
+    get getMembers(): {
+        (): ReadonlyMap<__String, Symbol>;
+        gen(): Generator<ProtocolRequest, ReadonlyMap<__String, Symbol>, ProtocolResponse["result"]>;
+    };
     /**
      * 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(): ReadonlyMap<__String, Symbol>;
-    private fetchSymbolTable;
-    getExportSymbol(): Symbol;
-    getJsDocTags(checker: Checker): readonly JSDocTagInfo[];
-    getDocumentationComment(checker: Checker): string;
+    get getExports(): {
+        (): ReadonlyMap<__String, Symbol>;
+        gen(): Generator<ProtocolRequest, ReadonlyMap<__String, Symbol>, ProtocolResponse["result"]>;
+    };
+    private get fetchSymbolTable();
+    get getExportSymbol(): {
+        (): Symbol;
+        gen(): Generator<ProtocolRequest, Symbol, ProtocolResponse["result"]>;
+    };
+    get getJsDocTags(): {
+        (checker: Checker): readonly JSDocTagInfo[];
+        gen(checker: Checker): Generator<ProtocolRequest, readonly JSDocTagInfo[], ProtocolResponse["result"]>;
+    };
+    get getDocumentationComment(): {
+        (checker: Checker): string;
+        gen(checker: Checker): Generator<ProtocolRequest, string, ProtocolResponse["result"]>;
+    };
 }
 declare class TypeObject implements Type {
     private objectRegistry;
@@ -633,43 +1098,136 @@ declare class TypeObject implements Type {
     private stringIndexType;
     private numberIndexType;
     constructor(data: TypeResponse, objectRegistry: ProjectObjectRegistry);
-    getSymbol(): Symbol | undefined;
-    getProperties(): readonly Symbol[];
-    getProperty(propertyName: string): Symbol | undefined;
-    getApparentProperties(): readonly Symbol[];
-    getCallSignatures(): readonly Signature[];
-    getConstructSignatures(): readonly Signature[];
-    getNonNullableType(): Type;
-    getStringIndexType(): Type | undefined;
-    private getStringIndexTypeWorker;
-    getNumberIndexType(): Type | undefined;
-    private getNumberIndexTypeWorker;
-    getApparentType(): Type;
-    getReducedType(): Type;
-    getIndexInfos(): readonly IndexInfo[];
-    getAliasSymbol(): Symbol | undefined;
-    getTarget(): Type;
-    getFreshType(): FreshableType | undefined;
-    getRegularType(): FreshableType | undefined;
-    getTypes(): readonly Type[] | undefined;
-    getTypeParameters(): readonly TypeParameter[];
-    getOuterTypeParameters(): readonly TypeParameter[];
-    getLocalTypeParameters(): readonly TypeParameter[];
-    getAliasTypeArguments(): readonly Type[];
-    getObjectType(): Type;
-    getIndexType(): Type;
-    getCheckType(): Type;
-    getExtendsType(): Type;
-    getBaseType(): Type;
-    getConstraint(): Type | undefined;
-    getDefault(): Type | undefined;
-    getTrueType(): Type;
-    getFalseType(): Type;
+    get getSymbol(): {
+        (): Symbol | undefined;
+        gen(): Generator<ProtocolRequest, Symbol | undefined, ProtocolResponse["result"]>;
+    };
+    get getProperties(): {
+        (): readonly Symbol[];
+        gen(): Generator<ProtocolRequest, readonly Symbol[], ProtocolResponse["result"]>;
+    };
+    get getProperty(): {
+        (propertyName: string): Symbol | undefined;
+        gen(propertyName: string): Generator<ProtocolRequest, Symbol | undefined, ProtocolResponse["result"]>;
+    };
+    get getApparentProperties(): {
+        (): readonly Symbol[];
+        gen(): Generator<ProtocolRequest, readonly Symbol[], ProtocolResponse["result"]>;
+    };
+    get getCallSignatures(): {
+        (): readonly Signature[];
+        gen(): Generator<ProtocolRequest, readonly Signature[], ProtocolResponse["result"]>;
+    };
+    get getConstructSignatures(): {
+        (): readonly Signature[];
+        gen(): Generator<ProtocolRequest, readonly Signature[], ProtocolResponse["result"]>;
+    };
+    get getNonNullableType(): {
+        (): Type;
+        gen(): Generator<ProtocolRequest, Type, ProtocolResponse["result"]>;
+    };
+    get getStringIndexType(): {
+        (): Type | undefined;
+        gen(): Generator<ProtocolRequest, Type | undefined, ProtocolResponse["result"]>;
+    };
+    private get getStringIndexTypeWorker();
+    get getNumberIndexType(): {
+        (): Type | undefined;
+        gen(): Generator<ProtocolRequest, Type | undefined, ProtocolResponse["result"]>;
+    };
+    private get getNumberIndexTypeWorker();
+    get getApparentType(): {
+        (): Type;
+        gen(): Generator<ProtocolRequest, Type, ProtocolResponse["result"]>;
+    };
+    get getReducedType(): {
+        (): Type;
+        gen(): Generator<ProtocolRequest, Type, ProtocolResponse["result"]>;
+    };
+    get getIndexInfos(): {
+        (): readonly IndexInfo[];
+        gen(): Generator<ProtocolRequest, readonly IndexInfo[], ProtocolResponse["result"]>;
+    };
+    get getAliasSymbol(): {
+        (): Symbol | undefined;
+        gen(): Generator<ProtocolRequest, Symbol | undefined, ProtocolResponse["result"]>;
+    };
+    get getTarget(): {
+        (): Type;
+        gen(): Generator<ProtocolRequest, Type, ProtocolResponse["result"]>;
+    };
+    get getFreshType(): {
+        (): FreshableType | undefined;
+        gen(): Generator<ProtocolRequest, FreshableType | undefined, ProtocolResponse["result"]>;
+    };
+    get getRegularType(): {
+        (): FreshableType | undefined;
+        gen(): Generator<ProtocolRequest, FreshableType | undefined, ProtocolResponse["result"]>;
+    };
+    get getTypes(): {
+        (): readonly Type[] | undefined;
+        gen(): Generator<ProtocolRequest, readonly Type[] | undefined, ProtocolResponse["result"]>;
+    };
+    get getTypeParameters(): {
+        (): readonly TypeParameter[];
+        gen(): Generator<ProtocolRequest, readonly TypeParameter[], ProtocolResponse["result"]>;
+    };
+    get getOuterTypeParameters(): {
+        (): readonly TypeParameter[];
+        gen(): Generator<ProtocolRequest, readonly TypeParameter[], ProtocolResponse["result"]>;
+    };
+    get getLocalTypeParameters(): {
+        (): readonly TypeParameter[];
+        gen(): Generator<ProtocolRequest, readonly TypeParameter[], ProtocolResponse["result"]>;
+    };
+    get getAliasTypeArguments(): {
+        (): readonly Type[];
+        gen(): Generator<ProtocolRequest, readonly Type[], ProtocolResponse["result"]>;
+    };
+    get getObjectType(): {
+        (): Type;
+        gen(): Generator<ProtocolRequest, Type, ProtocolResponse["result"]>;
+    };
+    get getIndexType(): {
+        (): Type;
+        gen(): Generator<ProtocolRequest, Type, ProtocolResponse["result"]>;
+    };
+    get getCheckType(): {
+        (): Type;
+        gen(): Generator<ProtocolRequest, Type, ProtocolResponse["result"]>;
+    };
+    get getExtendsType(): {
+        (): Type;
+        gen(): Generator<ProtocolRequest, Type, ProtocolResponse["result"]>;
+    };
+    get getBaseType(): {
+        (): Type;
+        gen(): Generator<ProtocolRequest, Type, ProtocolResponse["result"]>;
+    };
+    get getConstraint(): {
+        (): Type | undefined;
+        gen(): Generator<ProtocolRequest, Type | undefined, ProtocolResponse["result"]>;
+    };
+    get getDefault(): {
+        (): Type | undefined;
+        gen(): Generator<ProtocolRequest, Type | undefined, ProtocolResponse["result"]>;
+    };
+    get getTrueType(): {
+        (): Type;
+        gen(): Generator<ProtocolRequest, Type, ProtocolResponse["result"]>;
+    };
+    get getFalseType(): {
+        (): Type;
+        gen(): Generator<ProtocolRequest, Type, ProtocolResponse["result"]>;
+    };
     /**
      * Get the base types of this type. Returns `undefined` for any type that is
      * not a class or interface.
      */
-    getBaseTypes(): readonly Type[] | undefined;
+    get getBaseTypes(): {
+        (): readonly Type[] | undefined;
+        gen(): Generator<ProtocolRequest, readonly Type[] | undefined, ProtocolResponse["result"]>;
+    };
     isClassOrInterface(): this is InterfaceType;
     isUnionType(): this is UnionType;
     isIntersectionType(): this is IntersectionType;
@@ -728,12 +1286,30 @@ export declare class Signature {
     readonly target?: number | undefined;
     private returnType;
     constructor(data: SignatureResponse, project: Project, objectRegistry: ProjectObjectRegistry);
-    getTypeParameters(): readonly TypeParameter[];
-    getParameters(): readonly Symbol[];
-    getThisParameter(): Symbol | undefined;
-    getTarget(): Signature | undefined;
-    getReturnType(): Type;
-    getTypeParameterAtPosition(pos: number): Type;
+    get getTypeParameters(): {
+        (): readonly TypeParameter[];
+        gen(): Generator<ProtocolRequest, readonly TypeParameter[], ProtocolResponse["result"]>;
+    };
+    get getParameters(): {
+        (): readonly Symbol[];
+        gen(): Generator<ProtocolRequest, readonly Symbol[], ProtocolResponse["result"]>;
+    };
+    get getThisParameter(): {
+        (): Symbol | undefined;
+        gen(): Generator<ProtocolRequest, Symbol | undefined, ProtocolResponse["result"]>;
+    };
+    get getTarget(): {
+        (): Signature | undefined;
+        gen(): Generator<ProtocolRequest, Signature | undefined, ProtocolResponse["result"]>;
+    };
+    get getReturnType(): {
+        (): Type;
+        gen(): Generator<ProtocolRequest, Type, ProtocolResponse["result"]>;
+    };
+    get getTypeParameterAtPosition(): {
+        (pos: number): Type;
+        gen(pos: number): Generator<ProtocolRequest, Type, ProtocolResponse["result"]>;
+    };
     get hasRestParameter(): boolean;
     get isConstruct(): boolean;
     get isAbstract(): boolean;