typescript 7.1.0-dev.20260827.1 → 7.1.0-dev.20260829.1

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

@@ -1,9 +1,12 @@
+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";
 import { ElementFlags } from "#enums/elementFlags";
 import { EmitOnly } from "#enums/emitOnly";
+import { JsxEmit } from "#enums/jsxEmit";
 import { ModuleKind } from "#enums/moduleKind";
+import { ModuleResolutionKind } from "#enums/moduleResolutionKind";
 import { NodeBuilderFlags } from "#enums/nodeBuilderFlags";
 import { ObjectFlags } from "#enums/objectFlags";
 import { SignatureFlags } from "#enums/signatureFlags";
@@ -14,15 +17,15 @@ 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 { APIFileChanges, CompilerOptions, CreateProgramOptions, 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";
-import type { AssertsIdentifierTypePredicate, AssertsThisTypePredicate, BigIntLiteralType, BooleanLiteralType, CompletionEntry, CompletionInfo, CompletionOptions, ConditionalType, EmitOutput, EmitOutputFile, EmitResult, FormatDiagnosticsHost, FreshableType, GetImportEditsForSymbolsOptions, IdentifierTypePredicate, ImportAdderAction as APIImportAdderAction, IndexedAccessType, IndexInfo, IndexType, InterfaceType, IntersectionType, IntrinsicType, JSDocTagInfo, LiteralType, NumberLiteralType, ObjectType, StringLiteralType, StringMappingType, StructuredType, SubstitutionType, TemplateLiteralType, ThisTypePredicate, TupleType, Type, TypeParameter, TypePredicate, TypePredicateBase, TypeReference, UnionOrIntersectionType, UnionType } from "./types.ts";
+import type { AssertsIdentifierTypePredicate, AssertsThisTypePredicate, BigIntLiteralType, BooleanLiteralType, CompletionEntry, CompletionInfo, CompletionOptions, ConditionalType, EmitOutput, EmitOutputFile, EmitResult, FormatDiagnosticsHost, FreshableType, GetImportEditsForSymbolsOptions, IdentifierTypePredicate, ImportAdderAction as APIImportAdderAction, IndexedAccessType, IndexInfo, IndexType, InterfaceType, IntersectionType, IntrinsicType, JSDocTagInfo, LiteralType, NumberLiteralType, ObjectType, StringLiteralType, StringMappingType, StructuredType, SubstitutionType, TemplateLiteralType, ThisTypePredicate, TupleType, TupleTypeReference, Type, TypeParameter, TypePredicate, TypePredicateBase, TypeReference, UnionOrIntersectionType, UnionType } from "./types.ts";
 export { formatDiagnostics, formatDiagnosticsWithColorAndContext } from "../diagnosticFormatter.ts";
 export { documentURIToFileName, fileNameToDocumentURI } from "../path.ts";
-export { CheckFlags, CompletionItemKind, DiagnosticCategory, ElementFlags, EmitOnly, ModifierFlags, ModuleKind, NodeBuilderFlags, ObjectFlags, SignatureFlags, SignatureKind, SymbolFlags, TypeFlags, TypeFormatFlags, TypePredicateKind };
-export type { APIImportAdderAction as ImportAdderAction, APIOptions, AssertsIdentifierTypePredicate, AssertsThisTypePredicate, BigIntLiteralType, BooleanLiteralType, ClientSocketOptions, ClientSpawnOptions, CompilerOptions, CompletionEntry, CompletionInfo, CompletionOptions, ConditionalType, Diagnostic, DocumentIdentifier, DocumentPosition, EmitOutput, EmitOutputFile, EmitResult, FormatDiagnosticsHost, FreshableType, GetImportEditsForSymbolsOptions, IdentifierTypePredicate, IndexedAccessType, IndexInfo, IndexType, InterfaceType, IntersectionType, IntrinsicType, JSDocTagInfo, LiteralType, LSPConnectionOptions, NumberLiteralType, ObjectType, ParsedCommandLine, ProjectReference, ReadConfigFileResponse, RequestTiming, SourceFileMetadata, StringLiteralType, StringMappingType, StructuredType, SubstitutionType, TemplateLiteralType, TextEdit, ThisTypePredicate, TimingAccumulators, TimingInfo, TupleType, Type, TypeAcquisition, TypeParameter, TypePredicate, TypePredicateBase, TypeReference, UnionOrIntersectionType, UnionType, };
+export { CheckFlags, CompletionItemKind, DiagnosticCategory, ElementFlags, EmitOnly, JsxEmit, ModifierFlags, ModuleKind, ModuleResolutionKind, NodeBuilderFlags, ObjectFlags, SignatureFlags, SignatureKind, SymbolFlags, TypeFlags, TypeFormatFlags, TypePredicateKind };
+export type { APIFileChanges, APIImportAdderAction as ImportAdderAction, APIOptions, AssertsIdentifierTypePredicate, AssertsThisTypePredicate, BigIntLiteralType, BooleanLiteralType, ClientSocketOptions, ClientSpawnOptions, CompilerOptions, CompletionEntry, CompletionInfo, CompletionOptions, ConditionalType, CreateProgramOptions, Diagnostic, DocumentIdentifier, DocumentPosition, EmitOutput, EmitOutputFile, EmitResult, FormatDiagnosticsHost, FreshableType, GetImportEditsForSymbolsOptions, IdentifierTypePredicate, IndexedAccessType, IndexInfo, IndexType, InterfaceType, IntersectionType, IntrinsicType, JSDocTagInfo, LiteralType, LSPConnectionOptions, NumberLiteralType, ObjectType, ParsedCommandLine, ProjectReference, ReadConfigFileResponse, RequestTiming, SourceFileMetadata, StringLiteralType, StringMappingType, StructuredType, SubstitutionType, TemplateLiteralType, TextEdit, ThisTypePredicate, TimingAccumulators, TimingInfo, TupleType, TupleTypeReference, Type, TypeAcquisition, TypeParameter, TypePredicate, TypePredicateBase, TypeReference, UnionOrIntersectionType, UnionType, };
 export interface TranspileOptions {
     compilerOptions?: CompilerOptions;
     fileName?: string;
@@ -33,6 +36,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 +53,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(): {
+        (file: DocumentIdentifier, options?: TranspileOptions): TranspileOutput;
+        gen(file: DocumentIdentifier, 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(): {
+        (file: DocumentIdentifier, options?: TranspileOptions): TranspileOutput;
+        gen(file: DocumentIdentifier, 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 +130,44 @@ 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"]>;
+    };
+    private isProgramActive;
+    /**
+     * Creates a program from current filesystem state, or derives one from oldProgram after applying fileChanges.
+     */
+    get createProgram(): {
+        (rootFiles: readonly DocumentIdentifier[], createProgramOptions: CreateProgramOptions, oldProgram?: Program, fileChanges?: APIFileChanges): Program;
+        gen(rootFiles: readonly DocumentIdentifier[], createProgramOptions: CreateProgramOptions, oldProgram?: Program, fileChanges?: APIFileChanges): Generator<ProtocolRequest, Program, 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 +181,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 +204,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 +228,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 +298,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,120 +315,205 @@ 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;
-    private project;
-    private client;
-    private sourceFileCache;
-    private toPath;
-    private formatDiagnosticsHost;
-    private decoder;
-    private sourceFileMetadataCache;
+    /** @internal */
+    readonly snapshotId: number;
+    private readonly project;
+    private readonly client;
+    private readonly sourceFileCache;
+    private readonly toPath;
+    private readonly formatDiagnosticsHost;
+    private readonly decoder;
+    private readonly sourceFileMetadataCache;
+    private ownedSnapshot;
     constructor(snapshotId: number, project: Project, client: Client, sourceFileCache: SourceFileCache, toPath: (fileName: string) => Path, formatDiagnosticsHost: FormatDiagnosticsHost);
     getCurrentDirectory(): string;
     getCanonicalFileName(fileName: string): string;
     getNewLine(): string;
+    /** @internal */
+    setOwnedSnapshot(snapshot: Snapshot): void;
+    [globalThis.Symbol.dispose](): void;
+    get dispose(): {
+        (): void;
+        gen(): Generator<ProtocolRequest, void, ProtocolResponse["result"]>;
+    };
     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(): {
+        (file: DocumentIdentifier): SourceFileMetadata | undefined;
+        gen(file: DocumentIdentifier): 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"]>;
+    };
+    getProject(): Project;
 }
 export declare class Checker {
     private snapshotId;
@@ -311,187 +524,436 @@ 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"]>;
+    };
+    get isTupleTypeTarget(): {
+        (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 +963,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 +981,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 +1002,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 +1045,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;
@@ -602,6 +1091,7 @@ declare class TypeObject implements Type {
     readonly freshType: number;
     readonly regularType: number;
     readonly target: number;
+    private readonly tupleType;
     readonly typeParameters: readonly number[];
     readonly outerTypeParameters: readonly number[];
     readonly localTypeParameters: readonly number[];
@@ -633,43 +1123,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;
@@ -682,7 +1265,8 @@ declare class TypeObject implements Type {
     isBigIntLiteralType(): this is BigIntLiteralType;
     isBooleanLiteralType(): this is BooleanLiteralType;
     isTypeReference(): this is TypeReference;
-    isTupleType(): this is TupleType;
+    isTupleType(): this is TupleTypeReference;
+    isTupleTypeTarget(): this is TupleType;
     isIndexType(): this is IndexType;
     isIndexedAccessType(): this is IndexedAccessType;
     isConditionalType(): this is ConditionalType;
@@ -709,7 +1293,8 @@ export declare function isNumberLiteralType(type: Type): type is NumberLiteralTy
 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 isTupleType(type: Type): type is TupleTypeReference;
+export declare function isTupleTypeTarget(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;
@@ -728,12 +1313,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;