typescript 7.1.0-dev.20260826.1 → 7.1.0-dev.20260828.1

package/dist/api/sync/api.js

@@ -1,11 +1,4 @@
-//
-// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-// !!! THIS FILE IS AUTO-GENERATED - DO NOT EDIT !!!
-// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-//
-// Source: src/api/async/api.ts
-// Regenerate: npm run generate (from packages/typescript)
-//
+import { apiRequest, cacheGeneratorMethod, } from "./generatorSupport.js";
 import { CheckFlags } from "#enums/checkFlags";
 import { CompletionItemKind } from "#enums/completionItemKind";
 import { DiagnosticCategory } from "#enums/diagnosticCategory";
@@ -33,6 +26,8 @@ import { Client, } from "./client.js";
 export { formatDiagnostics, formatDiagnosticsWithColorAndContext } from "../diagnosticFormatter.js";
 export { documentURIToFileName, fileNameToDocumentURI } from "../path.js";
 export { CheckFlags, CompletionItemKind, DiagnosticCategory, ElementFlags, EmitOnly, ModifierFlags, ModuleKind, NodeBuilderFlags, ObjectFlags, SignatureFlags, SignatureKind, SymbolFlags, TypeFlags, TypeFormatFlags, TypePredicateKind };
+export { all } from "./generatorSupport.js";
+import { all, } from "./generatorSupport.js";
 export class API {
     client;
     sourceFileCache;
@@ -46,33 +41,55 @@ export class API {
     constructor(options = {}) {
         this.client = new Client(options);
         this.sourceFileCache = new SourceFileCache();
-        this.internal = new InternalAPI(this.client, () => this.ensureInitialized());
+        this.internal = new InternalAPI(this.client, this.ensureInitialized);
     }
     /**
      * 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) {
-        const api = new API(options);
-        api.ensureInitialized();
-        return api;
-    }
-    batchRequests(requests) {
-        const response = this.client.apiRequest("batchRequests", { requests });
-        // we're replacing the `unknown`s in the autogenerated types with much more specific per-request types here, which creates some variance issues for the
-        // `batchRequests` method within the batch request object itself, so we cast.
-        return response;
-    }
-    ensureInitialized() {
-        if (!this.initialized) {
-            const response = this.client.apiRequest("initialize", null);
-            const getCanonicalFileName = createGetCanonicalFileName(response.useCaseSensitiveFileNames);
-            const currentDirectory = response.currentDirectory;
-            this.getCanonicalFileNameWorker = getCanonicalFileName;
-            this.currentDirectory = currentDirectory;
-            this.toPath = (fileName) => toPath(fileName, currentDirectory, getCanonicalFileName);
-            this.initialized = true;
+    static get fromLSPConnection() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "fromLSPConnection", function (options) {
+            const api = new API(options);
+            api.ensureInitialized();
+            return api;
+        }, function* (options) {
+            const api = new API(options);
+            yield* api.ensureInitialized.gen();
+            return api;
+        });
+    }
+    batch(...requestGenerators) {
+        const batches = all(...requestGenerators);
+        let state = batches.next();
+        while (!state.done) {
+            state = batches.next(this.client.batchRequests(state.value).responses);
         }
+        return state.value;
+    }
+    get ensureInitialized() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "ensureInitialized", function () {
+            if (!owner.initialized) {
+                const response = owner.client.apiRequest("initialize", null);
+                const getCanonicalFileName = createGetCanonicalFileName(response.useCaseSensitiveFileNames);
+                const currentDirectory = response.currentDirectory;
+                owner.getCanonicalFileNameWorker = getCanonicalFileName;
+                owner.currentDirectory = currentDirectory;
+                owner.toPath = (fileName) => toPath(fileName, currentDirectory, getCanonicalFileName);
+                owner.initialized = true;
+            }
+        }, function* () {
+            if (!owner.initialized) {
+                const response = yield* apiRequest("initialize", null);
+                const getCanonicalFileName = createGetCanonicalFileName(response.useCaseSensitiveFileNames);
+                const currentDirectory = response.currentDirectory;
+                owner.getCanonicalFileNameWorker = getCanonicalFileName;
+                owner.currentDirectory = currentDirectory;
+                owner.toPath = (fileName) => toPath(fileName, currentDirectory, getCanonicalFileName);
+                owner.initialized = true;
+            }
+        });
     }
     getCurrentDirectory() {
         if (this.currentDirectory === undefined) {
@@ -89,96 +106,206 @@ export class API {
     getNewLine() {
         return "\n";
     }
-    parseConfigFile(file) {
-        this.ensureInitialized();
-        return this.client.apiRequest("parseConfigFile", { file });
-    }
-    parseCommandLine(commandLine) {
-        this.ensureInitialized();
-        return this.client.apiRequest("parseCommandLine", { commandLine });
-    }
-    readConfigFile(file) {
-        this.ensureInitialized();
-        return this.client.apiRequest("readConfigFile", { file });
-    }
-    parseJsonConfigFileContent(json, options) {
-        this.ensureInitialized();
-        return this.client.apiRequest("parseJsonConfigFileContent", { json, ...options });
-    }
-    transpileModule(input, options = {}) {
-        this.ensureInitialized();
-        return this.client.apiRequest("transpileModule", { input, options });
-    }
-    transpileModuleFromFile(fileName, options = {}) {
-        this.ensureInitialized();
-        return this.client.apiRequest("transpileModuleFromFile", { fileName, options });
-    }
-    transpileDeclaration(input, options = {}) {
-        this.ensureInitialized();
-        return this.client.apiRequest("transpileDeclaration", { input, options });
-    }
-    transpileDeclarationFromFile(fileName, options = {}) {
-        this.ensureInitialized();
-        return this.client.apiRequest("transpileDeclarationFromFile", { fileName, options });
-    }
-    updateSnapshot(params) {
-        this.ensureInitialized();
-        const requestParams = toUpdateSnapshotRequest(params);
-        const data = this.client.apiRequest("updateSnapshot", requestParams);
-        // Retain cached source files from previous snapshot for unchanged files
-        if (this.latestSnapshot) {
-            this.sourceFileCache.retainForSnapshot(data.snapshot, this.latestSnapshot.id, data.changes);
-            if (this.latestSnapshot.isDisposed()) {
-                this.sourceFileCache.releaseSnapshot(this.latestSnapshot.id);
+    get parseConfigFile() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "parseConfigFile", function (file) {
+            owner.ensureInitialized();
+            return owner.client.apiRequest("parseConfigFile", { file });
+        }, function* (file) {
+            yield* owner.ensureInitialized.gen();
+            return yield* apiRequest("parseConfigFile", { file });
+        });
+    }
+    get parseCommandLine() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "parseCommandLine", function (commandLine) {
+            owner.ensureInitialized();
+            return owner.client.apiRequest("parseCommandLine", { commandLine });
+        }, function* (commandLine) {
+            yield* owner.ensureInitialized.gen();
+            return yield* apiRequest("parseCommandLine", { commandLine });
+        });
+    }
+    get readConfigFile() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "readConfigFile", function (file) {
+            owner.ensureInitialized();
+            return owner.client.apiRequest("readConfigFile", { file });
+        }, function* (file) {
+            yield* owner.ensureInitialized.gen();
+            return yield* apiRequest("readConfigFile", { file });
+        });
+    }
+    get parseJsonConfigFileContent() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "parseJsonConfigFileContent", function (json, options) {
+            owner.ensureInitialized();
+            return owner.client.apiRequest("parseJsonConfigFileContent", { json, ...options });
+        }, function* (json, options) {
+            yield* owner.ensureInitialized.gen();
+            return yield* apiRequest("parseJsonConfigFileContent", { json, ...options });
+        });
+    }
+    get transpileModule() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "transpileModule", function (input, options = {}) {
+            owner.ensureInitialized();
+            return owner.client.apiRequest("transpileModule", { input, options });
+        }, function* (input, options = {}) {
+            yield* owner.ensureInitialized.gen();
+            return yield* apiRequest("transpileModule", { input, options });
+        });
+    }
+    get transpileModuleFromFile() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "transpileModuleFromFile", function (fileName, options = {}) {
+            owner.ensureInitialized();
+            return owner.client.apiRequest("transpileModuleFromFile", { fileName, options });
+        }, function* (fileName, options = {}) {
+            yield* owner.ensureInitialized.gen();
+            return yield* apiRequest("transpileModuleFromFile", { fileName, options });
+        });
+    }
+    get transpileDeclaration() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "transpileDeclaration", function (input, options = {}) {
+            owner.ensureInitialized();
+            return owner.client.apiRequest("transpileDeclaration", { input, options });
+        }, function* (input, options = {}) {
+            yield* owner.ensureInitialized.gen();
+            return yield* apiRequest("transpileDeclaration", { input, options });
+        });
+    }
+    get transpileDeclarationFromFile() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "transpileDeclarationFromFile", function (fileName, options = {}) {
+            owner.ensureInitialized();
+            return owner.client.apiRequest("transpileDeclarationFromFile", { fileName, options });
+        }, function* (fileName, options = {}) {
+            yield* owner.ensureInitialized.gen();
+            return yield* apiRequest("transpileDeclarationFromFile", { fileName, options });
+        });
+    }
+    get updateSnapshot() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "updateSnapshot", function (params) {
+            owner.ensureInitialized();
+            const requestParams = toUpdateSnapshotRequest(params);
+            const data = owner.client.apiRequest("updateSnapshot", requestParams);
+            // Retain cached source files from previous snapshot for unchanged files
+            if (owner.latestSnapshot) {
+                owner.sourceFileCache.retainForSnapshot(data.snapshot, owner.latestSnapshot.id, data.changes);
+                if (owner.latestSnapshot.isDisposed()) {
+                    owner.sourceFileCache.releaseSnapshot(owner.latestSnapshot.id);
+                }
             }
-        }
-        const snapshot = new Snapshot(data, this.client, this.sourceFileCache, this.toPath, this, () => {
-            this.activeSnapshots.delete(snapshot);
-            if (snapshot !== this.latestSnapshot) {
-                this.sourceFileCache.releaseSnapshot(snapshot.id);
+            const snapshot = new Snapshot(data, owner.client, owner.sourceFileCache, owner.toPath, owner, () => {
+                owner.activeSnapshots.delete(snapshot);
+                if (snapshot !== owner.latestSnapshot) {
+                    owner.sourceFileCache.releaseSnapshot(snapshot.id);
+                }
+            });
+            owner.latestSnapshot = snapshot;
+            owner.activeSnapshots.add(snapshot);
+            return snapshot;
+        }, function* (params) {
+            yield* owner.ensureInitialized.gen();
+            const requestParams = toUpdateSnapshotRequest(params);
+            const data = yield* apiRequest("updateSnapshot", requestParams);
+            // Retain cached source files from previous snapshot for unchanged files
+            if (owner.latestSnapshot) {
+                owner.sourceFileCache.retainForSnapshot(data.snapshot, owner.latestSnapshot.id, data.changes);
+                if (owner.latestSnapshot.isDisposed()) {
+                    owner.sourceFileCache.releaseSnapshot(owner.latestSnapshot.id);
+                }
             }
+            const snapshot = new Snapshot(data, owner.client, owner.sourceFileCache, owner.toPath, owner, () => {
+                owner.activeSnapshots.delete(snapshot);
+                if (snapshot !== owner.latestSnapshot) {
+                    owner.sourceFileCache.releaseSnapshot(snapshot.id);
+                }
+            });
+            owner.latestSnapshot = snapshot;
+            owner.activeSnapshots.add(snapshot);
+            return snapshot;
         });
-        this.latestSnapshot = snapshot;
-        this.activeSnapshots.add(snapshot);
-        return snapshot;
     }
-    close() {
-        // Dispose all active snapshots
-        for (const snapshot of [...this.activeSnapshots]) {
-            snapshot.dispose();
-        }
-        // Release the latest snapshot's cache refs if still held
-        if (this.latestSnapshot) {
-            this.sourceFileCache.releaseSnapshot(this.latestSnapshot.id);
-            this.latestSnapshot = undefined;
-        }
-        this.client.close();
-        this.sourceFileCache.clear();
+    get close() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "close", function () {
+            // Dispose all active snapshots
+            for (const snapshot of [...owner.activeSnapshots]) {
+                snapshot.dispose();
+            }
+            // Release the latest snapshot's cache refs if still held
+            if (owner.latestSnapshot) {
+                owner.sourceFileCache.releaseSnapshot(owner.latestSnapshot.id);
+                owner.latestSnapshot = undefined;
+            }
+            owner.client.close();
+            owner.sourceFileCache.clear();
+        }, function* () {
+            // Dispose all active snapshots
+            for (const snapshot of [...owner.activeSnapshots]) {
+                yield* snapshot.dispose.gen();
+            }
+            // Release the latest snapshot's cache refs if still held
+            if (owner.latestSnapshot) {
+                owner.sourceFileCache.releaseSnapshot(owner.latestSnapshot.id);
+                owner.latestSnapshot = undefined;
+            }
+            owner.client.close();
+            owner.sourceFileCache.clear();
+        });
     }
     clearSourceFileCache() {
         this.sourceFileCache.clear();
     }
-    runWithTemporaryFileUpdate(baseSnapshot, file, newText, cb) {
-        this.ensureInitialized();
-        if (!this.activeSnapshots.has(baseSnapshot) || baseSnapshot.isDisposed()) {
-            throw new Error("Cannot run a temporary file update on an inactive snapshot");
-        }
-        const data = this.client.apiRequest("updateTemporarySnapshot", { snapshot: baseSnapshot.id, file, newText });
-        // Retain cached source files from the base snapshot for files unchanged by
-        // the temporary update. The temporary snapshot is not the latest snapshot, so
-        // we never release the latest snapshot's cache here.
-        this.sourceFileCache.retainForSnapshot(data.snapshot, baseSnapshot.id, data.changes);
-        const snapshot = new Snapshot(data, this.client, this.sourceFileCache, this.toPath, this, () => {
-            this.activeSnapshots.delete(snapshot);
-            this.sourceFileCache.releaseSnapshot(snapshot.id);
-        });
-        this.activeSnapshots.add(snapshot);
-        try {
-            cb(snapshot);
-        }
-        finally {
-            snapshot.dispose();
-        }
+    get runWithTemporaryFileUpdate() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "runWithTemporaryFileUpdate", function (baseSnapshot, file, newText, cb) {
+            owner.ensureInitialized();
+            if (!owner.activeSnapshots.has(baseSnapshot) || baseSnapshot.isDisposed()) {
+                throw new Error("Cannot run a temporary file update on an inactive snapshot");
+            }
+            const data = owner.client.apiRequest("updateTemporarySnapshot", { snapshot: baseSnapshot.id, file, newText });
+            // Retain cached source files from the base snapshot for files unchanged by
+            // the temporary update. The temporary snapshot is not the latest snapshot, so
+            // we never release the latest snapshot's cache here.
+            owner.sourceFileCache.retainForSnapshot(data.snapshot, baseSnapshot.id, data.changes);
+            const snapshot = new Snapshot(data, owner.client, owner.sourceFileCache, owner.toPath, owner, () => {
+                owner.activeSnapshots.delete(snapshot);
+                owner.sourceFileCache.releaseSnapshot(snapshot.id);
+            });
+            owner.activeSnapshots.add(snapshot);
+            try {
+                cb(snapshot);
+            }
+            finally {
+                snapshot.dispose();
+            }
+        }, function* (baseSnapshot, file, newText, cb) {
+            yield* owner.ensureInitialized.gen();
+            if (!owner.activeSnapshots.has(baseSnapshot) || baseSnapshot.isDisposed()) {
+                throw new Error("Cannot run a temporary file update on an inactive snapshot");
+            }
+            const data = yield* apiRequest("updateTemporarySnapshot", { snapshot: baseSnapshot.id, file, newText });
+            // Retain cached source files from the base snapshot for files unchanged by
+            // the temporary update. The temporary snapshot is not the latest snapshot, so
+            // we never release the latest snapshot's cache here.
+            owner.sourceFileCache.retainForSnapshot(data.snapshot, baseSnapshot.id, data.changes);
+            const snapshot = new Snapshot(data, owner.client, owner.sourceFileCache, owner.toPath, owner, () => {
+                owner.activeSnapshots.delete(snapshot);
+                owner.sourceFileCache.releaseSnapshot(snapshot.id);
+            });
+            owner.activeSnapshots.add(snapshot);
+            try {
+                yield* (cb(snapshot) ?? []);
+            }
+            finally {
+                yield* snapshot.dispose.gen();
+            }
+        });
     }
     /**
      * Returns a snapshot of collected timing information for requests made
@@ -191,12 +318,22 @@ export class API {
      * `collectTiming` option; when it is not, the returned snapshot has
      * `enabled: false` and zeroed totals.
      */
-    getTimingInfo() {
-        return this.client.getTimingInfo();
+    get getTimingInfo() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getTimingInfo", function () {
+            return owner.client.getTimingInfo();
+        }, function* () {
+            return owner.client.getTimingInfo();
+        });
     }
     /** Clears all accumulated timing totals and recent-request history, on both the client and the server. */
-    resetTimingInfo() {
-        return this.client.resetTimingInfo();
+    get resetTimingInfo() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "resetTimingInfo", function () {
+            return owner.client.resetTimingInfo();
+        }, function* () {
+            return owner.client.resetTimingInfo();
+        });
     }
 }
 export class InternalAPI {
@@ -207,19 +344,39 @@ export class InternalAPI {
         this.client = client;
         this.ensureInitialized = ensureInitialized;
     }
-    startCPUProfile(dir) {
-        this.ensureInitialized();
-        this.client.apiRequest("startCPUProfile", { dir });
-    }
-    stopCPUProfile() {
-        this.ensureInitialized();
-        const result = this.client.apiRequest("stopCPUProfile", null);
-        return result.file;
-    }
-    saveHeapProfile(dir) {
-        this.ensureInitialized();
-        const result = this.client.apiRequest("saveHeapProfile", { dir });
-        return result.file;
+    get startCPUProfile() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "startCPUProfile", function (dir) {
+            owner.ensureInitialized();
+            owner.client.apiRequest("startCPUProfile", { dir });
+        }, function* (dir) {
+            yield* owner.ensureInitialized.gen();
+            yield* apiRequest("startCPUProfile", { dir });
+        });
+    }
+    get stopCPUProfile() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "stopCPUProfile", function () {
+            owner.ensureInitialized();
+            const result = owner.client.apiRequest("stopCPUProfile", null);
+            return result.file;
+        }, function* () {
+            yield* owner.ensureInitialized.gen();
+            const result = yield* apiRequest("stopCPUProfile", null);
+            return result.file;
+        });
+    }
+    get saveHeapProfile() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "saveHeapProfile", function (dir) {
+            owner.ensureInitialized();
+            const result = owner.client.apiRequest("saveHeapProfile", { dir });
+            return result.file;
+        }, function* (dir) {
+            yield* owner.ensureInitialized.gen();
+            const result = yield* apiRequest("saveHeapProfile", { dir });
+            return result.file;
+        });
     }
 }
 export class Snapshot {
@@ -252,30 +409,56 @@ export class Snapshot {
         this.ensureNotDisposed();
         return this.projectMap.get(this.toPath(configFileName));
     }
-    getDefaultProjectForFile(file) {
-        this.ensureNotDisposed();
-        const data = this.client.apiRequest("getDefaultProjectForFile", {
-            snapshot: this.id,
-            file,
+    get getDefaultProjectForFile() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getDefaultProjectForFile", function (file) {
+            owner.ensureNotDisposed();
+            const data = owner.client.apiRequest("getDefaultProjectForFile", {
+                snapshot: owner.id,
+                file,
+            });
+            if (!data)
+                return undefined;
+            return owner.projectMap.get(owner.toPath(data.configFileName));
+        }, function* (file) {
+            owner.ensureNotDisposed();
+            const data = yield* apiRequest("getDefaultProjectForFile", {
+                snapshot: owner.id,
+                file,
+            });
+            if (!data)
+                return undefined;
+            return owner.projectMap.get(owner.toPath(data.configFileName));
         });
-        if (!data)
-            return undefined;
-        return this.projectMap.get(this.toPath(data.configFileName));
     }
     [globalThis.Symbol.dispose]() {
         this.dispose();
     }
-    dispose() {
-        if (this.disposed)
-            return;
-        this.disposed = true;
-        for (const project of this.projectMap.values()) {
-            project.dispose();
-        }
-        this.projectMap.clear();
-        this.snapshotRegistry.clear();
-        this.onDispose();
-        this.client.apiRequest("release", { snapshot: this.id });
+    get dispose() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "dispose", function () {
+            if (owner.disposed)
+                return;
+            owner.disposed = true;
+            for (const project of owner.projectMap.values()) {
+                project.dispose();
+            }
+            owner.projectMap.clear();
+            owner.snapshotRegistry.clear();
+            owner.onDispose();
+            owner.client.apiRequest("release", { snapshot: owner.id });
+        }, function* () {
+            if (owner.disposed)
+                return;
+            owner.disposed = true;
+            for (const project of owner.projectMap.values()) {
+                project.dispose();
+            }
+            owner.projectMap.clear();
+            owner.snapshotRegistry.clear();
+            owner.onDispose();
+            yield* apiRequest("release", { snapshot: owner.id });
+        });
     }
     isDisposed() {
         return this.disposed;
@@ -314,45 +497,89 @@ class SnapshotObjectRegistry {
     clear() {
         this.symbols.clear();
     }
-    fetchSymbol(source, method, handle, projectId) {
-        if (!handle)
-            return undefined;
-        const cached = this.getSymbol(handle);
-        if (cached)
-            return cached;
-        const data = this.client.apiRequest(method, {
-            snapshot: this.snapshotId,
-            project: projectId,
-            objectId: source.id,
-        });
-        if (!data)
-            throw new Error(`${method} returned null symbol for ${source.constructor.name} ${source.id}`);
-        return this.getOrCreateSymbol(data);
-    }
-    fetchSymbols(source, method, handles, projectId) {
-        if (handles) {
-            const result = new Array(handles.length);
-            let allCached = true;
-            for (let i = 0; i < handles.length; i++) {
-                const cached = this.getSymbol(handles[i]);
-                if (!cached) {
-                    allCached = false;
-                    break;
+    get fetchSymbol() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "fetchSymbol", function (source, method, handle, projectId) {
+            if (!handle)
+                return undefined;
+            const cached = owner.getSymbol(handle);
+            if (cached)
+                return cached;
+            const data = owner.client.apiRequest(method, {
+                snapshot: owner.snapshotId,
+                project: projectId,
+                objectId: source.id,
+            });
+            if (!data)
+                throw new Error(`${method} returned null symbol for ${source.constructor.name} ${source.id}`);
+            return owner.getOrCreateSymbol(data);
+        }, function* (source, method, handle, projectId) {
+            if (!handle)
+                return undefined;
+            const cached = owner.getSymbol(handle);
+            if (cached)
+                return cached;
+            const data = yield* apiRequest(method, {
+                snapshot: owner.snapshotId,
+                project: projectId,
+                objectId: source.id,
+            });
+            if (!data)
+                throw new Error(`${method} returned null symbol for ${source.constructor.name} ${source.id}`);
+            return owner.getOrCreateSymbol(data);
+        });
+    }
+    get fetchSymbols() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "fetchSymbols", function (source, method, handles, projectId) {
+            if (handles) {
+                const result = new Array(handles.length);
+                let allCached = true;
+                for (let i = 0; i < handles.length; i++) {
+                    const cached = owner.getSymbol(handles[i]);
+                    if (!cached) {
+                        allCached = false;
+                        break;
+                    }
+                    result[i] = cached;
                 }
-                result[i] = cached;
+                if (allCached)
+                    return result;
             }
-            if (allCached)
-                return result;
-        }
-        const symbolData = this.client.apiRequest(method, {
-            snapshot: this.snapshotId,
-            project: projectId,
-            objectId: source.id,
+            const symbolData = owner.client.apiRequest(method, {
+                snapshot: owner.snapshotId,
+                project: projectId,
+                objectId: source.id,
+            });
+            if (symbolData == null)
+                return [];
+            else
+                return symbolData.map(data => owner.getOrCreateSymbol(data));
+        }, function* (source, method, handles, projectId) {
+            if (handles) {
+                const result = new Array(handles.length);
+                let allCached = true;
+                for (let i = 0; i < handles.length; i++) {
+                    const cached = owner.getSymbol(handles[i]);
+                    if (!cached) {
+                        allCached = false;
+                        break;
+                    }
+                    result[i] = cached;
+                }
+                if (allCached)
+                    return result;
+            }
+            const symbolData = yield* apiRequest(method, {
+                snapshot: owner.snapshotId,
+                project: projectId,
+                objectId: source.id,
+            });
+            if (symbolData == null)
+                return [];
+            else
+                return symbolData.map(data => owner.getOrCreateSymbol(data));
         });
-        if (symbolData == null)
-            return [];
-        else
-            return symbolData.map(data => this.getOrCreateSymbol(data));
     }
 }
 class ProjectObjectRegistry {
@@ -400,144 +627,307 @@ class ProjectObjectRegistry {
         this.types.clear();
         this.signatures.clear();
     }
-    fetchOptionalType(source, method, handle) {
-        if (handle !== false) {
+    get fetchOptionalType() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "fetchOptionalType", function (source, method, handle) {
+            if (handle !== false) {
+                if (!handle)
+                    return undefined;
+                const cached = owner.getType(handle);
+                if (cached)
+                    return cached;
+            }
+            const data = owner.client.apiRequest(method, {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                objectId: source.id,
+            });
+            if (!data)
+                return undefined;
+            return owner.getOrCreateType(data);
+        }, function* (source, method, handle) {
+            if (handle !== false) {
+                if (!handle)
+                    return undefined;
+                const cached = owner.getType(handle);
+                if (cached)
+                    return cached;
+            }
+            const data = yield* apiRequest(method, {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                objectId: source.id,
+            });
+            if (!data)
+                return undefined;
+            return owner.getOrCreateType(data);
+        });
+    }
+    get fetchType() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "fetchType", function (source, method, handle) {
+            const result = owner.fetchOptionalType(source, method, handle);
+            if (result === undefined)
+                throw new Error(`${method} returned no type for ${source.constructor.name} ${source.id}`);
+            return result;
+        }, function* (source, method, handle) {
+            const result = yield* owner.fetchOptionalType.gen(source, method, handle);
+            if (result === undefined)
+                throw new Error(`${method} returned no type for ${source.constructor.name} ${source.id}`);
+            return result;
+        });
+    }
+    get fetchSymbol() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "fetchSymbol", function (source, method, handle) {
+            return owner.snapshotRegistry.fetchSymbol(source, method, handle, owner.project.id);
+        }, function* (source, method, handle) {
+            return yield* owner.snapshotRegistry.fetchSymbol.gen(source, method, handle, owner.project.id);
+        });
+    }
+    get fetchSignature() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "fetchSignature", function (source, method, handle) {
             if (!handle)
                 return undefined;
-            const cached = this.getType(handle);
+            const cached = owner.getSignature(handle);
             if (cached)
                 return cached;
-        }
-        const data = this.client.apiRequest(method, {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            objectId: source.id,
-        });
-        if (!data)
-            return undefined;
-        return this.getOrCreateType(data);
-    }
-    fetchType(source, method, handle) {
-        const result = this.fetchOptionalType(source, method, handle);
-        if (result === undefined)
-            throw new Error(`${method} returned no type for ${source.constructor.name} ${source.id}`);
-        return result;
-    }
-    fetchSymbol(source, method, handle) {
-        return this.snapshotRegistry.fetchSymbol(source, method, handle, this.project.id);
-    }
-    fetchSignature(source, method, handle) {
-        if (!handle)
-            return undefined;
-        const cached = this.getSignature(handle);
-        if (cached)
-            return cached;
-        const data = this.client.apiRequest(method, {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            objectId: source.id,
-        });
-        if (!data)
-            throw new Error(`${method} returned null signature for ${source.constructor.name} ${source.id}`);
-        return this.getOrCreateSignature(data);
-    }
-    fetchTypes(source, method, handles) {
-        if (handles) {
-            const result = new Array(handles.length);
-            let allCached = true;
-            for (let i = 0; i < handles.length; i++) {
-                const cached = this.getType(handles[i]);
-                if (!cached) {
-                    allCached = false;
-                    break;
+            const data = owner.client.apiRequest(method, {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                objectId: source.id,
+            });
+            if (!data)
+                throw new Error(`${method} returned null signature for ${source.constructor.name} ${source.id}`);
+            return owner.getOrCreateSignature(data);
+        }, function* (source, method, handle) {
+            if (!handle)
+                return undefined;
+            const cached = owner.getSignature(handle);
+            if (cached)
+                return cached;
+            const data = yield* apiRequest(method, {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                objectId: source.id,
+            });
+            if (!data)
+                throw new Error(`${method} returned null signature for ${source.constructor.name} ${source.id}`);
+            return owner.getOrCreateSignature(data);
+        });
+    }
+    get fetchTypes() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "fetchTypes", function (source, method, handles) {
+            if (handles) {
+                const result = new Array(handles.length);
+                let allCached = true;
+                for (let i = 0; i < handles.length; i++) {
+                    const cached = owner.getType(handles[i]);
+                    if (!cached) {
+                        allCached = false;
+                        break;
+                    }
+                    result[i] = cached;
                 }
-                result[i] = cached;
+                if (allCached)
+                    return result;
             }
-            if (allCached)
-                return result;
-        }
-        const typesData = this.client.apiRequest(method, {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            objectId: source.id,
+            const typesData = owner.client.apiRequest(method, {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                objectId: source.id,
+            });
+            if (typesData == null)
+                return [];
+            else
+                return typesData.map(data => owner.getOrCreateType(data));
+        }, function* (source, method, handles) {
+            if (handles) {
+                const result = new Array(handles.length);
+                let allCached = true;
+                for (let i = 0; i < handles.length; i++) {
+                    const cached = owner.getType(handles[i]);
+                    if (!cached) {
+                        allCached = false;
+                        break;
+                    }
+                    result[i] = cached;
+                }
+                if (allCached)
+                    return result;
+            }
+            const typesData = yield* apiRequest(method, {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                objectId: source.id,
+            });
+            if (typesData == null)
+                return [];
+            else
+                return typesData.map(data => owner.getOrCreateType(data));
         });
-        if (typesData == null)
-            return [];
-        else
-            return typesData.map(data => this.getOrCreateType(data));
     }
-    fetchSymbols(source, method, handles) {
-        return this.snapshotRegistry.fetchSymbols(source, method, handles, this.project.id);
+    get fetchSymbols() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "fetchSymbols", function (source, method, handles) {
+            return owner.snapshotRegistry.fetchSymbols(source, method, handles, owner.project.id);
+        }, function* (source, method, handles) {
+            return yield* owner.snapshotRegistry.fetchSymbols.gen(source, method, handles, owner.project.id);
+        });
     }
     // getBaseTypes is a checker-level endpoint keyed by `type` (not `objectId`),
     // so it cannot go through fetchTypes. This helper reuses that server method.
-    fetchBaseTypes(source) {
-        const typesData = this.client.apiRequest("getBaseTypes", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            type: source.id,
-        });
-        if (typesData == null)
-            return [];
-        return typesData.map(data => this.getOrCreateType(data));
-    }
-    fetchPropertiesOfType(source) {
-        const data = this.client.apiRequest("getPropertiesOfType", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            type: source.id,
-        });
-        return data ? data.map(symbol => this.getOrCreateSymbol(symbol)) : [];
-    }
-    fetchApparentPropertiesOfType(source) {
-        const data = this.client.apiRequest("getApparentPropertiesOfType", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            objectId: source.id,
-        });
-        return data ? data.map(symbol => this.getOrCreateSymbol(symbol)) : [];
-    }
-    fetchPropertyOfType(source, name) {
-        const data = this.client.apiRequest("getPropertyOfType", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            type: source.id,
-            name,
-        });
-        return data ? this.getOrCreateSymbol(data) : undefined;
-    }
-    fetchSignaturesOfType(source, kind) {
-        const data = this.client.apiRequest("getSignaturesOfType", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            type: source.id,
-            kind,
-        });
-        return data.map(signature => this.getOrCreateSignature(signature));
-    }
-    fetchIndexInfosOfType(source) {
-        const data = this.client.apiRequest("getIndexInfosOfType", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            type: source.id,
-        });
-        if (!data)
-            return [];
-        return data.map(info => ({
-            keyType: this.getOrCreateType(info.keyType),
-            valueType: this.getOrCreateType(info.valueType),
-            isReadonly: info.isReadonly ?? false,
-            declaration: info.declaration ? new NodeHandle(info.declaration, this.project) : undefined,
-        }));
-    }
-    fetchTypeParameterAtPosition(source, pos) {
-        const data = this.client.apiRequest("getTypeParameterAtPosition", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            signature: source.id,
-            index: pos,
-        });
-        return this.getOrCreateType(data);
+    get fetchBaseTypes() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "fetchBaseTypes", function (source) {
+            const typesData = owner.client.apiRequest("getBaseTypes", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                type: source.id,
+            });
+            if (typesData == null)
+                return [];
+            return typesData.map(data => owner.getOrCreateType(data));
+        }, function* (source) {
+            const typesData = yield* apiRequest("getBaseTypes", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                type: source.id,
+            });
+            if (typesData == null)
+                return [];
+            return typesData.map(data => owner.getOrCreateType(data));
+        });
+    }
+    get fetchPropertiesOfType() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "fetchPropertiesOfType", function (source) {
+            const data = owner.client.apiRequest("getPropertiesOfType", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                type: source.id,
+            });
+            return data ? data.map(symbol => owner.getOrCreateSymbol(symbol)) : [];
+        }, function* (source) {
+            const data = yield* apiRequest("getPropertiesOfType", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                type: source.id,
+            });
+            return data ? data.map(symbol => owner.getOrCreateSymbol(symbol)) : [];
+        });
+    }
+    get fetchApparentPropertiesOfType() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "fetchApparentPropertiesOfType", function (source) {
+            const data = owner.client.apiRequest("getApparentPropertiesOfType", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                objectId: source.id,
+            });
+            return data ? data.map(symbol => owner.getOrCreateSymbol(symbol)) : [];
+        }, function* (source) {
+            const data = yield* apiRequest("getApparentPropertiesOfType", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                objectId: source.id,
+            });
+            return data ? data.map(symbol => owner.getOrCreateSymbol(symbol)) : [];
+        });
+    }
+    get fetchPropertyOfType() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "fetchPropertyOfType", function (source, name) {
+            const data = owner.client.apiRequest("getPropertyOfType", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                type: source.id,
+                name,
+            });
+            return data ? owner.getOrCreateSymbol(data) : undefined;
+        }, function* (source, name) {
+            const data = yield* apiRequest("getPropertyOfType", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                type: source.id,
+                name,
+            });
+            return data ? owner.getOrCreateSymbol(data) : undefined;
+        });
+    }
+    get fetchSignaturesOfType() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "fetchSignaturesOfType", function (source, kind) {
+            const data = owner.client.apiRequest("getSignaturesOfType", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                type: source.id,
+                kind,
+            });
+            return data.map(signature => owner.getOrCreateSignature(signature));
+        }, function* (source, kind) {
+            const data = yield* apiRequest("getSignaturesOfType", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                type: source.id,
+                kind,
+            });
+            return data.map(signature => owner.getOrCreateSignature(signature));
+        });
+    }
+    get fetchIndexInfosOfType() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "fetchIndexInfosOfType", function (source) {
+            const data = owner.client.apiRequest("getIndexInfosOfType", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                type: source.id,
+            });
+            if (!data)
+                return [];
+            return data.map(info => ({
+                keyType: owner.getOrCreateType(info.keyType),
+                valueType: owner.getOrCreateType(info.valueType),
+                isReadonly: info.isReadonly ?? false,
+                declaration: info.declaration ? new NodeHandle(info.declaration, owner.project) : undefined,
+            }));
+        }, function* (source) {
+            const data = yield* apiRequest("getIndexInfosOfType", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                type: source.id,
+            });
+            if (!data)
+                return [];
+            return data.map(info => ({
+                keyType: owner.getOrCreateType(info.keyType),
+                valueType: owner.getOrCreateType(info.valueType),
+                isReadonly: info.isReadonly ?? false,
+                declaration: info.declaration ? new NodeHandle(info.declaration, owner.project) : undefined,
+            }));
+        });
+    }
+    get fetchTypeParameterAtPosition() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "fetchTypeParameterAtPosition", function (source, pos) {
+            const data = owner.client.apiRequest("getTypeParameterAtPosition", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                signature: source.id,
+                index: pos,
+            });
+            return owner.getOrCreateType(data);
+        }, function* (source, pos) {
+            const data = yield* apiRequest("getTypeParameterAtPosition", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                signature: source.id,
+                index: pos,
+            });
+            return owner.getOrCreateType(data);
+        });
     }
 }
 export class Project {
@@ -574,12 +964,22 @@ export class Project {
         this.languageService = new LanguageService(snapshotId, this, client, objectRegistry);
     }
     /** @deprecated Use `languageService.getImportAdderEdits`. */
-    getImportAdderEdits(file, actions) {
-        return this.languageService.getImportAdderEdits(file, actions);
+    get getImportAdderEdits() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getImportAdderEdits", function (file, actions) {
+            return owner.languageService.getImportAdderEdits(file, actions);
+        }, function* (file, actions) {
+            return yield* owner.languageService.getImportAdderEdits.gen(file, actions);
+        });
     }
     /** @deprecated Use `languageService.getImportEditsForSymbols`. */
-    getImportEditsForSymbols(file, symbols, options = {}) {
-        return this.languageService.getImportEditsForSymbols(file, symbols, options);
+    get getImportEditsForSymbols() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getImportEditsForSymbols", function (file, symbols, options = {}) {
+            return owner.languageService.getImportEditsForSymbols(file, symbols, options);
+        }, function* (file, symbols, options = {}) {
+            return yield* owner.languageService.getImportEditsForSymbols.gen(file, symbols, options);
+        });
     }
     dispose() {
         this.checker.dispose();
@@ -596,87 +996,179 @@ export class LanguageService {
         this.client = client;
         this.objectRegistry = objectRegistry;
     }
-    getImportAdderEdits(file, actions) {
-        const requestActions = actions.map(action => {
-            switch (action.kind) {
-                case "importSymbol":
-                    const importSymbolAction = {
-                        kind: "importSymbol",
-                        symbol: action.symbol.id,
-                    };
-                    if (action.isValidTypeOnlyUseSite !== undefined) {
-                        importSymbolAction.isValidTypeOnlyUseSite = action.isValidTypeOnlyUseSite;
-                    }
-                    return importSymbolAction;
-                default:
-                    return assertNever(action.kind);
-            }
-        });
-        const data = this.client.apiRequest("getImportAdderEdits", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            file,
-            actions: requestActions,
+    get getImportAdderEdits() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getImportAdderEdits", function (file, actions) {
+            const requestActions = actions.map(action => {
+                switch (action.kind) {
+                    case "importSymbol":
+                        const importSymbolAction = {
+                            kind: "importSymbol",
+                            symbol: action.symbol.id,
+                        };
+                        if (action.isValidTypeOnlyUseSite !== undefined) {
+                            importSymbolAction.isValidTypeOnlyUseSite = action.isValidTypeOnlyUseSite;
+                        }
+                        return importSymbolAction;
+                    default:
+                        return assertNever(action.kind);
+                }
+            });
+            const data = owner.client.apiRequest("getImportAdderEdits", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                file,
+                actions: requestActions,
+            });
+            return data ?? [];
+        }, function* (file, actions) {
+            const requestActions = actions.map(action => {
+                switch (action.kind) {
+                    case "importSymbol":
+                        const importSymbolAction = {
+                            kind: "importSymbol",
+                            symbol: action.symbol.id,
+                        };
+                        if (action.isValidTypeOnlyUseSite !== undefined) {
+                            importSymbolAction.isValidTypeOnlyUseSite = action.isValidTypeOnlyUseSite;
+                        }
+                        return importSymbolAction;
+                    default:
+                        return assertNever(action.kind);
+                }
+            });
+            const data = yield* apiRequest("getImportAdderEdits", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                file,
+                actions: requestActions,
+            });
+            return data ?? [];
         });
-        return data ?? [];
     }
-    getImportEditsForSymbols(file, symbols, options = {}) {
-        return this.getImportAdderEdits(file, symbols.map((symbol) => {
-            if (options.isValidTypeOnlyUseSite !== undefined) {
+    get getImportEditsForSymbols() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getImportEditsForSymbols", function (file, symbols, options = {}) {
+            return owner.getImportAdderEdits(file, symbols.map((symbol) => {
+                if (options.isValidTypeOnlyUseSite !== undefined) {
+                    return {
+                        kind: "importSymbol",
+                        symbol,
+                        isValidTypeOnlyUseSite: options.isValidTypeOnlyUseSite,
+                    };
+                }
                 return {
                     kind: "importSymbol",
                     symbol,
-                    isValidTypeOnlyUseSite: options.isValidTypeOnlyUseSite,
                 };
-            }
+            }));
+        }, function* (file, symbols, options = {}) {
+            return yield* owner.getImportAdderEdits.gen(file, symbols.map((symbol) => {
+                if (options.isValidTypeOnlyUseSite !== undefined) {
+                    return {
+                        kind: "importSymbol",
+                        symbol,
+                        isValidTypeOnlyUseSite: options.isValidTypeOnlyUseSite,
+                    };
+                }
+                return {
+                    kind: "importSymbol",
+                    symbol,
+                };
+            }));
+        });
+    }
+    get getReferencedSymbolsForNode() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getReferencedSymbolsForNode", function (node, position) {
+            const data = owner.client.apiRequest("getReferencedSymbolsForNode", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                node: getNodeId(node),
+                position,
+            });
+            return (data ?? []).map(entry => ({
+                definition: new NodeHandle(entry.definition, owner.project),
+                symbol: entry.symbol ? owner.objectRegistry.getOrCreateSymbol(entry.symbol) : undefined,
+                references: (entry.references ?? []).map(h => new NodeHandle(h, owner.project)),
+            }));
+        }, function* (node, position) {
+            const data = yield* apiRequest("getReferencedSymbolsForNode", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                node: getNodeId(node),
+                position,
+            });
+            return (data ?? []).map(entry => ({
+                definition: new NodeHandle(entry.definition, owner.project),
+                symbol: entry.symbol ? owner.objectRegistry.getOrCreateSymbol(entry.symbol) : undefined,
+                references: (entry.references ?? []).map(h => new NodeHandle(h, owner.project)),
+            }));
+        });
+    }
+    get getSignatureUsage() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getSignatureUsage", function (signatureDecl) {
+            const data = owner.client.apiRequest("getSignatureUsages", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                signatureDecl: getNodeId(signatureDecl),
+            });
+            return (data ?? []).map(entry => ({
+                name: new NodeHandle(entry.name, owner.project),
+                call: entry.call ? new NodeHandle(entry.call, owner.project) : undefined,
+            }));
+        }, function* (signatureDecl) {
+            const data = yield* apiRequest("getSignatureUsages", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                signatureDecl: getNodeId(signatureDecl),
+            });
+            return (data ?? []).map(entry => ({
+                name: new NodeHandle(entry.name, owner.project),
+                call: entry.call ? new NodeHandle(entry.call, owner.project) : undefined,
+            }));
+        });
+    }
+    get getCompletionsAtPosition() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getCompletionsAtPosition", function (document, position, options) {
+            const data = owner.client.apiRequest("getCompletionsAtPosition", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                file: document,
+                position,
+                ...(options?.triggerCharacter !== undefined ? { triggerCharacter: options.triggerCharacter } : {}),
+                ...(options?.includeSymbol !== undefined ? { includeSymbol: options.includeSymbol } : {}),
+            });
+            if (!data)
+                return undefined;
             return {
-                kind: "importSymbol",
-                symbol,
+                isIncomplete: data.isIncomplete,
+                entries: data.entries.map(e => ({
+                    ...e,
+                    symbol: e.symbol ? owner.objectRegistry.getOrCreateSymbol(e.symbol) : undefined,
+                })),
             };
-        }));
-    }
-    getReferencedSymbolsForNode(node, position) {
-        const data = this.client.apiRequest("getReferencedSymbolsForNode", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            node: getNodeId(node),
-            position,
-        });
-        return (data ?? []).map(entry => ({
-            definition: new NodeHandle(entry.definition, this.project),
-            symbol: entry.symbol ? this.objectRegistry.getOrCreateSymbol(entry.symbol) : undefined,
-            references: (entry.references ?? []).map(h => new NodeHandle(h, this.project)),
-        }));
-    }
-    getSignatureUsage(signatureDecl) {
-        const data = this.client.apiRequest("getSignatureUsages", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            signatureDecl: getNodeId(signatureDecl),
-        });
-        return (data ?? []).map(entry => ({
-            name: new NodeHandle(entry.name, this.project),
-            call: entry.call ? new NodeHandle(entry.call, this.project) : undefined,
-        }));
-    }
-    getCompletionsAtPosition(document, position, options) {
-        const data = this.client.apiRequest("getCompletionsAtPosition", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            file: document,
-            position,
-            ...(options?.triggerCharacter !== undefined ? { triggerCharacter: options.triggerCharacter } : {}),
-            ...(options?.includeSymbol !== undefined ? { includeSymbol: options.includeSymbol } : {}),
-        });
-        if (!data)
-            return undefined;
-        return {
-            isIncomplete: data.isIncomplete,
-            entries: data.entries.map(e => ({
-                ...e,
-                symbol: e.symbol ? this.objectRegistry.getOrCreateSymbol(e.symbol) : undefined,
-            })),
-        };
+        }, function* (document, position, options) {
+            const data = yield* apiRequest("getCompletionsAtPosition", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                file: document,
+                position,
+                ...(options?.triggerCharacter !== undefined ? { triggerCharacter: options.triggerCharacter } : {}),
+                ...(options?.includeSymbol !== undefined ? { includeSymbol: options.includeSymbol } : {}),
+            });
+            if (!data)
+                return undefined;
+            return {
+                isIncomplete: data.isIncomplete,
+                entries: data.entries.map(e => ({
+                    ...e,
+                    symbol: e.symbol ? owner.objectRegistry.getOrCreateSymbol(e.symbol) : undefined,
+                })),
+            };
+        });
     }
 }
 export class Program {
@@ -708,44 +1200,84 @@ export class Program {
     getCompilerOptions() {
         return this.project.compilerOptions;
     }
-    getSourceFile(file) {
-        const fileName = resolveFileName(file);
-        const path = this.toPath(fileName);
-        // Check if we already have a retained cache entry for this (snapshot, project) pair
-        const retained = this.sourceFileCache.getRetained(path, this.snapshotId, this.project.id);
-        if (retained) {
-            return retained;
-        }
-        // Fetch from server
-        const binaryData = this.client.apiRequestBinary("getSourceFile", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            file,
-        });
-        if (!binaryData) {
-            return undefined;
-        }
-        const view = new DataView(binaryData.buffer, binaryData.byteOffset, binaryData.byteLength);
-        const contentHash = readSourceFileHash(view);
-        const parseOptionsKey = readParseOptionsKey(view);
-        // Create a new RemoteSourceFile and cache it (set returns existing if hash matches)
-        const sourceFile = new RemoteSourceFile(binaryData, this.decoder, this.client.getTimingCollector());
-        return this.sourceFileCache.set(path, sourceFile, parseOptionsKey, contentHash, this.snapshotId, this.project.id);
-    }
-    getSourceFileNames() {
-        const data = this.client.apiRequest("getSourceFileNames", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
+    get getSourceFile() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getSourceFile", function (file) {
+            const fileName = resolveFileName(file);
+            const path = owner.toPath(fileName);
+            // Check if we already have a retained cache entry for this (snapshot, project) pair
+            const retained = owner.sourceFileCache.getRetained(path, owner.snapshotId, owner.project.id);
+            if (retained) {
+                return retained;
+            }
+            // Fetch from server
+            const binaryData = owner.client.apiRequestBinary("getSourceFile", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                file,
+            });
+            if (!binaryData) {
+                return undefined;
+            }
+            const view = new DataView(binaryData.buffer, binaryData.byteOffset, binaryData.byteLength);
+            const contentHash = readSourceFileHash(view);
+            const parseOptionsKey = readParseOptionsKey(view);
+            // Create a new RemoteSourceFile and cache it (set returns existing if hash matches)
+            const sourceFile = new RemoteSourceFile(binaryData, owner.decoder, owner.client.getTimingCollector());
+            return owner.sourceFileCache.set(path, sourceFile, parseOptionsKey, contentHash, owner.snapshotId, owner.project.id);
+        }, function* (file) {
+            const fileName = resolveFileName(file);
+            const path = owner.toPath(fileName);
+            // Check if we already have a retained cache entry for this (snapshot, project) pair
+            const retained = owner.sourceFileCache.getRetained(path, owner.snapshotId, owner.project.id);
+            if (retained) {
+                return retained;
+            }
+            // Fetch from server
+            const binaryData = owner.client.apiRequestBinary("getSourceFile", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                file,
+            });
+            if (!binaryData) {
+                return undefined;
+            }
+            const view = new DataView(binaryData.buffer, binaryData.byteOffset, binaryData.byteLength);
+            const contentHash = readSourceFileHash(view);
+            const parseOptionsKey = readParseOptionsKey(view);
+            // Create a new RemoteSourceFile and cache it (set returns existing if hash matches)
+            const sourceFile = new RemoteSourceFile(binaryData, owner.decoder, owner.client.getTimingCollector());
+            return owner.sourceFileCache.set(path, sourceFile, parseOptionsKey, contentHash, owner.snapshotId, owner.project.id);
+        });
+    }
+    get getSourceFileNames() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getSourceFileNames", function () {
+            const data = owner.client.apiRequest("getSourceFileNames", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+            });
+            return data ?? [];
+        }, function* () {
+            const data = yield* apiRequest("getSourceFileNames", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+            });
+            return data ?? [];
         });
-        return data ?? [];
     }
     /**
      * 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) {
-        return this.getSourceFileMetadataByPath(this.toPath(fileName));
+    get getSourceFileMetadata() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getSourceFileMetadata", function (fileName) {
+            return owner.getSourceFileMetadataByPath(owner.toPath(fileName));
+        }, function* (fileName) {
+            return yield* owner.getSourceFileMetadataByPath.gen(owner.toPath(fileName));
+        });
     }
     /**
      * Returns program-stored metadata for the source file at the given path, or `undefined`
@@ -753,170 +1285,316 @@ export class Program {
      * the file name to path conversion. Metadata is fetched lazily per file and cached on
      * this `Program` instance.
      */
-    getSourceFileMetadataByPath(path) {
-        let metadata = this.sourceFileMetadataCache.get(path);
-        if (metadata === undefined) {
-            metadata = this.fetchSourceFileMetadata(path);
-            this.sourceFileMetadataCache.set(path, metadata);
-        }
-        return metadata;
+    get getSourceFileMetadataByPath() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getSourceFileMetadataByPath", function (path) {
+            let metadata = owner.sourceFileMetadataCache.get(path);
+            if (metadata === undefined) {
+                metadata = owner.fetchSourceFileMetadata(path);
+                owner.sourceFileMetadataCache.set(path, metadata);
+            }
+            return metadata;
+        }, function* (path) {
+            let metadata = owner.sourceFileMetadataCache.get(path);
+            if (metadata === undefined) {
+                metadata = yield* owner.fetchSourceFileMetadata.gen(path);
+                owner.sourceFileMetadataCache.set(path, metadata);
+            }
+            return metadata;
+        });
     }
-    fetchSourceFileMetadata(path) {
-        const data = this.client.apiRequest("getSourceFileMetadata", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            file: path,
+    get fetchSourceFileMetadata() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "fetchSourceFileMetadata", function (path) {
+            const data = owner.client.apiRequest("getSourceFileMetadata", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                file: path,
+            });
+            return data ?? undefined;
+        }, function* (path) {
+            const data = yield* apiRequest("getSourceFileMetadata", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                file: path,
+            });
+            return data ?? undefined;
         });
-        return data ?? undefined;
     }
     /**
      * 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) {
-        const metadata = this.getSourceFileMetadataByPath(file.path);
-        return metadata?.isFromExternalLibrary ?? false;
+    get isSourceFileFromExternalLibrary() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "isSourceFileFromExternalLibrary", function (file) {
+            const metadata = owner.getSourceFileMetadataByPath(file.path);
+            return metadata?.isFromExternalLibrary ?? false;
+        }, function* (file) {
+            const metadata = yield* owner.getSourceFileMetadataByPath.gen(file.path);
+            return metadata?.isFromExternalLibrary ?? false;
+        });
     }
     /**
      * 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) {
-        const metadata = this.getSourceFileMetadataByPath(file.path);
-        return metadata?.isDefaultLibrary ?? false;
+    get isSourceFileDefaultLibrary() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "isSourceFileDefaultLibrary", function (file) {
+            const metadata = owner.getSourceFileMetadataByPath(file.path);
+            return metadata?.isDefaultLibrary ?? false;
+        }, function* (file) {
+            const metadata = yield* owner.getSourceFileMetadataByPath.gen(file.path);
+            return metadata?.isDefaultLibrary ?? false;
+        });
     }
     /**
      * Get all config source file names associated with this program's project config.
      * Includes the root config file and any extended config files.
      */
-    getConfigFileNames() {
-        const data = this.client.apiRequest("getConfigFileNames", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
+    get getConfigFileNames() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getConfigFileNames", function () {
+            const data = owner.client.apiRequest("getConfigFileNames", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+            });
+            return data ?? [];
+        }, function* () {
+            const data = yield* apiRequest("getConfigFileNames", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+            });
+            return data ?? [];
         });
-        return data ?? [];
     }
     /**
      * 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) {
-        const binaryData = this.client.apiRequestBinary("getConfigSourceFile", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            file,
-        });
-        if (!binaryData) {
-            return undefined;
-        }
-        return new RemoteSourceFile(binaryData, this.decoder);
+    get getConfigSourceFile() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getConfigSourceFile", function (file) {
+            const binaryData = owner.client.apiRequestBinary("getConfigSourceFile", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                file,
+            });
+            if (!binaryData) {
+                return undefined;
+            }
+            return new RemoteSourceFile(binaryData, owner.decoder);
+        }, function* (file) {
+            const binaryData = owner.client.apiRequestBinary("getConfigSourceFile", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                file,
+            });
+            if (!binaryData) {
+                return undefined;
+            }
+            return new RemoteSourceFile(binaryData, owner.decoder);
+        });
     }
     /**
      * 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) {
-        const files = file === undefined ? undefined
-            : Array.isArray(file) ? file
-                : [file];
-        const data = this.client.apiRequest("getSyntacticDiagnostics", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            ...(files !== undefined ? { files } : {}),
+    get getSyntacticDiagnostics() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getSyntacticDiagnostics", function (file) {
+            const files = file === undefined ? undefined
+                : Array.isArray(file) ? file
+                    : [file];
+            const data = owner.client.apiRequest("getSyntacticDiagnostics", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                ...(files !== undefined ? { files } : {}),
+            });
+            return data ?? [];
+        }, function* (file) {
+            const files = file === undefined ? undefined
+                : Array.isArray(file) ? file
+                    : [file];
+            const data = yield* apiRequest("getSyntacticDiagnostics", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                ...(files !== undefined ? { files } : {}),
+            });
+            return data ?? [];
         });
-        return data ?? [];
     }
     /**
      * 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) {
-        const files = file === undefined ? undefined
-            : Array.isArray(file) ? file
-                : [file];
-        const data = this.client.apiRequest("getBindDiagnostics", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            ...(files !== undefined ? { files } : {}),
+    get getBindDiagnostics() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getBindDiagnostics", function (file) {
+            const files = file === undefined ? undefined
+                : Array.isArray(file) ? file
+                    : [file];
+            const data = owner.client.apiRequest("getBindDiagnostics", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                ...(files !== undefined ? { files } : {}),
+            });
+            return data ?? [];
+        }, function* (file) {
+            const files = file === undefined ? undefined
+                : Array.isArray(file) ? file
+                    : [file];
+            const data = yield* apiRequest("getBindDiagnostics", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                ...(files !== undefined ? { files } : {}),
+            });
+            return data ?? [];
         });
-        return data ?? [];
     }
     /**
      * 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) {
-        const files = file === undefined ? undefined
-            : Array.isArray(file) ? file
-                : [file];
-        const data = this.client.apiRequest("getSemanticDiagnostics", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            ...(files !== undefined ? { files } : {}),
+    get getSemanticDiagnostics() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getSemanticDiagnostics", function (file) {
+            const files = file === undefined ? undefined
+                : Array.isArray(file) ? file
+                    : [file];
+            const data = owner.client.apiRequest("getSemanticDiagnostics", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                ...(files !== undefined ? { files } : {}),
+            });
+            return data ?? [];
+        }, function* (file) {
+            const files = file === undefined ? undefined
+                : Array.isArray(file) ? file
+                    : [file];
+            const data = yield* apiRequest("getSemanticDiagnostics", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                ...(files !== undefined ? { files } : {}),
+            });
+            return data ?? [];
         });
-        return data ?? [];
     }
     /**
      * 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) {
-        const files = file === undefined ? undefined
-            : Array.isArray(file) ? file
-                : [file];
-        const data = this.client.apiRequest("getSuggestionDiagnostics", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            ...(files !== undefined ? { files } : {}),
+    get getSuggestionDiagnostics() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getSuggestionDiagnostics", function (file) {
+            const files = file === undefined ? undefined
+                : Array.isArray(file) ? file
+                    : [file];
+            const data = owner.client.apiRequest("getSuggestionDiagnostics", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                ...(files !== undefined ? { files } : {}),
+            });
+            return data ?? [];
+        }, function* (file) {
+            const files = file === undefined ? undefined
+                : Array.isArray(file) ? file
+                    : [file];
+            const data = yield* apiRequest("getSuggestionDiagnostics", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                ...(files !== undefined ? { files } : {}),
+            });
+            return data ?? [];
         });
-        return data ?? [];
     }
     /**
      * 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) {
-        const files = file === undefined ? undefined
-            : Array.isArray(file) ? file
-                : [file];
-        const data = this.client.apiRequest("getDeclarationDiagnostics", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            ...(files !== undefined ? { files } : {}),
+    get getDeclarationDiagnostics() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getDeclarationDiagnostics", function (file) {
+            const files = file === undefined ? undefined
+                : Array.isArray(file) ? file
+                    : [file];
+            const data = owner.client.apiRequest("getDeclarationDiagnostics", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                ...(files !== undefined ? { files } : {}),
+            });
+            return data ?? [];
+        }, function* (file) {
+            const files = file === undefined ? undefined
+                : Array.isArray(file) ? file
+                    : [file];
+            const data = yield* apiRequest("getDeclarationDiagnostics", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                ...(files !== undefined ? { files } : {}),
+            });
+            return data ?? [];
         });
-        return data ?? [];
     }
     /**
      * Get program-wide diagnostics for the project, including compiler options diagnostics.
      */
-    getProgramDiagnostics() {
-        const data = this.client.apiRequest("getProgramDiagnostics", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
+    get getProgramDiagnostics() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getProgramDiagnostics", function () {
+            const data = owner.client.apiRequest("getProgramDiagnostics", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+            });
+            return data ?? [];
+        }, function* () {
+            const data = yield* apiRequest("getProgramDiagnostics", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+            });
+            return data ?? [];
         });
-        return data ?? [];
     }
     /**
      * Get global (non-file-specific) semantic diagnostics for the project.
      */
-    getGlobalDiagnostics() {
-        const data = this.client.apiRequest("getGlobalDiagnostics", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
+    get getGlobalDiagnostics() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getGlobalDiagnostics", function () {
+            const data = owner.client.apiRequest("getGlobalDiagnostics", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+            });
+            return data ?? [];
+        }, function* () {
+            const data = yield* apiRequest("getGlobalDiagnostics", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+            });
+            return data ?? [];
         });
-        return data ?? [];
     }
     /**
      * Get config file parsing diagnostics for the project.
      */
-    getConfigFileParsingDiagnostics() {
-        const data = this.client.apiRequest("getConfigFileParsingDiagnostics", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
+    get getConfigFileParsingDiagnostics() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getConfigFileParsingDiagnostics", function () {
+            const data = owner.client.apiRequest("getConfigFileParsingDiagnostics", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+            });
+            return data ?? [];
+        }, function* () {
+            const data = yield* apiRequest("getConfigFileParsingDiagnostics", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+            });
+            return data ?? [];
         });
-        return data ?? [];
     }
     /**
      * Emits files to the configured filesystem.
@@ -924,50 +1602,94 @@ export class Program {
      * 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) {
-        const response = this.client.apiRequest("emit", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            ...(emitOnly !== undefined ? { emitOnly } : {}),
-        });
-        return {
-            emitSkipped: response.emitSkipped,
-            diagnostics: response.diagnostics,
-            emittedFiles: response.emittedFiles,
-        };
+    get emit() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "emit", function (emitOnly) {
+            const response = owner.client.apiRequest("emit", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                ...(emitOnly !== undefined ? { emitOnly } : {}),
+            });
+            return {
+                emitSkipped: response.emitSkipped,
+                diagnostics: response.diagnostics,
+                emittedFiles: response.emittedFiles,
+            };
+        }, function* (emitOnly) {
+            const response = yield* apiRequest("emit", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                ...(emitOnly !== undefined ? { emitOnly } : {}),
+            });
+            return {
+                emitSkipped: response.emitSkipped,
+                diagnostics: response.diagnostics,
+                emittedFiles: response.emittedFiles,
+            };
+        });
     }
     /**
      * Emits files and returns their contents without writing to the filesystem.
      */
-    emitToString(emitOnly) {
-        const response = this.client.apiRequest("emitToString", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            ...(emitOnly !== undefined ? { emitOnly } : {}),
+    get emitToString() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "emitToString", function (emitOnly) {
+            const response = owner.client.apiRequest("emitToString", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                ...(emitOnly !== undefined ? { emitOnly } : {}),
+            });
+            return toEmitOutput(response);
+        }, function* (emitOnly) {
+            const response = yield* apiRequest("emitToString", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                ...(emitOnly !== undefined ? { emitOnly } : {}),
+            });
+            return toEmitOutput(response);
         });
-        return toEmitOutput(response);
     }
     /**
      * Gets JavaScript output for selected files regardless of project `noEmit`, `emitDeclarationOnly`, and `noEmitOnError` settings.
      */
-    getJavaScriptEmit(files) {
-        const response = this.client.apiRequest("getJavaScriptEmit", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            files,
+    get getJavaScriptEmit() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getJavaScriptEmit", function (files) {
+            const response = owner.client.apiRequest("getJavaScriptEmit", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                files,
+            });
+            return toEmitOutput(response);
+        }, function* (files) {
+            const response = yield* apiRequest("getJavaScriptEmit", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                files,
+            });
+            return toEmitOutput(response);
         });
-        return toEmitOutput(response);
     }
     /**
      * Gets declaration output for selected files regardless of project `noEmit`, `declaration`, `emitDeclarationOnly`, and `noEmitOnError` settings.
      */
-    getDeclarationEmit(files) {
-        const response = this.client.apiRequest("getDeclarationEmit", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            files,
+    get getDeclarationEmit() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getDeclarationEmit", function (files) {
+            const response = owner.client.apiRequest("getDeclarationEmit", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                files,
+            });
+            return toEmitOutput(response);
+        }, function* (files) {
+            const response = yield* apiRequest("getDeclarationEmit", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                files,
+            });
+            return toEmitOutput(response);
         });
-        return toEmitOutput(response);
     }
 }
 function toEmitOutput(response) {
@@ -997,529 +1719,1219 @@ export class Checker {
     dispose() {
         this.objectRegistry.clear();
     }
-    getSymbolAtLocation(nodeOrNodes) {
-        if (Array.isArray(nodeOrNodes)) {
-            const data = this.client.apiRequest("getSymbolsAtLocations", {
-                snapshot: this.snapshotId,
-                project: this.project.id,
-                locations: nodeOrNodes.map(node => getNodeId(node)),
+    get getSymbolAtLocation() {
+        const owner = this;
+        function getSymbolAtLocation(nodeOrNodes) {
+            if (Array.isArray(nodeOrNodes)) {
+                const data = owner.client.apiRequest("getSymbolsAtLocations", {
+                    snapshot: owner.snapshotId,
+                    project: owner.project.id,
+                    locations: nodeOrNodes.map(node => getNodeId(node)),
+                });
+                return data.map(d => d ? owner.objectRegistry.getOrCreateSymbol(d) : undefined);
+            }
+            const data = owner.client.apiRequest("getSymbolAtLocation", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                location: getNodeId(nodeOrNodes),
             });
-            return data.map(d => d ? this.objectRegistry.getOrCreateSymbol(d) : undefined);
+            return data ? owner.objectRegistry.getOrCreateSymbol(data) : undefined;
         }
-        const data = this.client.apiRequest("getSymbolAtLocation", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            location: getNodeId(nodeOrNodes),
-        });
-        return data ? this.objectRegistry.getOrCreateSymbol(data) : undefined;
-    }
-    getSymbolAtPosition(file, positionOrPositions) {
-        if (typeof positionOrPositions === "number") {
-            const data = this.client.apiRequest("getSymbolAtPosition", {
-                snapshot: this.snapshotId,
-                project: this.project.id,
+        function* gen(nodeOrNodes) {
+            if (Array.isArray(nodeOrNodes)) {
+                const data = yield* apiRequest("getSymbolsAtLocations", {
+                    snapshot: owner.snapshotId,
+                    project: owner.project.id,
+                    locations: nodeOrNodes.map(node => getNodeId(node)),
+                });
+                return data.map(d => d ? owner.objectRegistry.getOrCreateSymbol(d) : undefined);
+            }
+            const data = yield* apiRequest("getSymbolAtLocation", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                location: getNodeId(nodeOrNodes),
+            });
+            return data ? owner.objectRegistry.getOrCreateSymbol(data) : undefined;
+        }
+        return cacheGeneratorMethod(owner, "getSymbolAtLocation", getSymbolAtLocation, gen);
+    }
+    get getSymbolAtPosition() {
+        const owner = this;
+        function getSymbolAtPosition(file, positionOrPositions) {
+            if (typeof positionOrPositions === "number") {
+                const data = owner.client.apiRequest("getSymbolAtPosition", {
+                    snapshot: owner.snapshotId,
+                    project: owner.project.id,
+                    file,
+                    position: positionOrPositions,
+                });
+                return data ? owner.objectRegistry.getOrCreateSymbol(data) : undefined;
+            }
+            const data = owner.client.apiRequest("getSymbolsAtPositions", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
                 file,
-                position: positionOrPositions,
+                positions: positionOrPositions,
             });
-            return data ? this.objectRegistry.getOrCreateSymbol(data) : undefined;
+            return data.map(d => d ? owner.objectRegistry.getOrCreateSymbol(d) : undefined);
         }
-        const data = this.client.apiRequest("getSymbolsAtPositions", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            file,
-            positions: positionOrPositions,
-        });
-        return data.map(d => d ? this.objectRegistry.getOrCreateSymbol(d) : undefined);
-    }
-    getSymbolOfSourceFile(fileOrFiles) {
-        if (Array.isArray(fileOrFiles)) {
-            const data = this.client.apiRequest("getSymbolsOfSourceFiles", {
-                snapshot: this.snapshotId,
-                project: this.project.id,
-                files: fileOrFiles,
-            });
-            return data.map(d => d ? this.objectRegistry.getOrCreateSymbol(d) : undefined);
+        function* gen(file, positionOrPositions) {
+            if (typeof positionOrPositions === "number") {
+                const data = yield* apiRequest("getSymbolAtPosition", {
+                    snapshot: owner.snapshotId,
+                    project: owner.project.id,
+                    file,
+                    position: positionOrPositions,
+                });
+                return data ? owner.objectRegistry.getOrCreateSymbol(data) : undefined;
+            }
+            const data = yield* apiRequest("getSymbolsAtPositions", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                file,
+                positions: positionOrPositions,
+            });
+            return data.map(d => d ? owner.objectRegistry.getOrCreateSymbol(d) : undefined);
         }
-        const data = this.client.apiRequest("getSymbolOfSourceFile", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            file: fileOrFiles,
-        });
-        return data ? this.objectRegistry.getOrCreateSymbol(data) : undefined;
+        return cacheGeneratorMethod(owner, "getSymbolAtPosition", getSymbolAtPosition, gen);
+    }
+    get getSymbolOfSourceFile() {
+        const owner = this;
+        function getSymbolOfSourceFile(fileOrFiles) {
+            if (Array.isArray(fileOrFiles)) {
+                const data = owner.client.apiRequest("getSymbolsOfSourceFiles", {
+                    snapshot: owner.snapshotId,
+                    project: owner.project.id,
+                    files: fileOrFiles,
+                });
+                return data.map(d => d ? owner.objectRegistry.getOrCreateSymbol(d) : undefined);
+            }
+            const data = owner.client.apiRequest("getSymbolOfSourceFile", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                file: fileOrFiles,
+            });
+            return data ? owner.objectRegistry.getOrCreateSymbol(data) : undefined;
+        }
+        function* gen(fileOrFiles) {
+            if (Array.isArray(fileOrFiles)) {
+                const data = yield* apiRequest("getSymbolsOfSourceFiles", {
+                    snapshot: owner.snapshotId,
+                    project: owner.project.id,
+                    files: fileOrFiles,
+                });
+                return data.map(d => d ? owner.objectRegistry.getOrCreateSymbol(d) : undefined);
+            }
+            const data = yield* apiRequest("getSymbolOfSourceFile", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                file: fileOrFiles,
+            });
+            return data ? owner.objectRegistry.getOrCreateSymbol(data) : undefined;
+        }
+        return cacheGeneratorMethod(owner, "getSymbolOfSourceFile", getSymbolOfSourceFile, gen);
     }
-    getTypeOfSymbol(symbolOrSymbols) {
-        if (Array.isArray(symbolOrSymbols)) {
-            const data = this.client.apiRequest("getTypesOfSymbols", {
-                snapshot: this.snapshotId,
-                project: this.project.id,
-                symbols: symbolOrSymbols.map(s => s.id),
+    /**
+     * 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).
+     */
+    get getTypeOfSymbol() {
+        const owner = this;
+        function getTypeOfSymbol(symbolOrSymbols) {
+            if (Array.isArray(symbolOrSymbols)) {
+                const data = owner.client.apiRequest("getTypesOfSymbols", {
+                    snapshot: owner.snapshotId,
+                    project: owner.project.id,
+                    symbols: symbolOrSymbols.map(s => s.id),
+                });
+                return data.map(d => owner.objectRegistry.getOrCreateType(d));
+            }
+            const data = owner.client.apiRequest("getTypeOfSymbol", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                symbol: symbolOrSymbols.id,
             });
-            return data.map(d => this.objectRegistry.getOrCreateType(d));
+            return owner.objectRegistry.getOrCreateType(data);
         }
-        const data = this.client.apiRequest("getTypeOfSymbol", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            symbol: symbolOrSymbols.id,
-        });
-        return this.objectRegistry.getOrCreateType(data);
+        function* gen(symbolOrSymbols) {
+            if (Array.isArray(symbolOrSymbols)) {
+                const data = yield* apiRequest("getTypesOfSymbols", {
+                    snapshot: owner.snapshotId,
+                    project: owner.project.id,
+                    symbols: symbolOrSymbols.map(s => s.id),
+                });
+                return data.map(d => owner.objectRegistry.getOrCreateType(d));
+            }
+            const data = yield* apiRequest("getTypeOfSymbol", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                symbol: symbolOrSymbols.id,
+            });
+            return owner.objectRegistry.getOrCreateType(data);
+        }
+        return cacheGeneratorMethod(owner, "getTypeOfSymbol", getTypeOfSymbol, gen);
     }
     /**
      * 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) {
-        const data = this.client.apiRequest("getDeclaredTypeOfSymbol", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            symbol: symbol.id,
+    get getDeclaredTypeOfSymbol() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getDeclaredTypeOfSymbol", function (symbol) {
+            const data = owner.client.apiRequest("getDeclaredTypeOfSymbol", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                symbol: symbol.id,
+            });
+            return owner.objectRegistry.getOrCreateType(data);
+        }, function* (symbol) {
+            const data = yield* apiRequest("getDeclaredTypeOfSymbol", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                symbol: symbol.id,
+            });
+            return owner.objectRegistry.getOrCreateType(data);
+        });
+    }
+    /**
+     * 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() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getNonMissingTypeOfSymbol", function (symbol) {
+            const data = owner.client.apiRequest("getNonMissingTypeOfSymbol", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                symbol: symbol.id,
+            });
+            return owner.objectRegistry.getOrCreateType(data);
+        }, function* (symbol) {
+            const data = yield* apiRequest("getNonMissingTypeOfSymbol", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                symbol: symbol.id,
+            });
+            return owner.objectRegistry.getOrCreateType(data);
         });
-        return this.objectRegistry.getOrCreateType(data);
     }
-    getReferencesToSymbolInFile(file, symbol) {
-        const data = this.client.apiRequest("getReferencesToSymbolInFile", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            file,
-            symbol: symbol.id,
+    get getReferencesToSymbolInFile() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getReferencesToSymbolInFile", function (file, symbol) {
+            const data = owner.client.apiRequest("getReferencesToSymbolInFile", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                file,
+                symbol: symbol.id,
+            });
+            return (data ?? []).map(h => new NodeHandle(h, owner.project));
+        }, function* (file, symbol) {
+            const data = yield* apiRequest("getReferencesToSymbolInFile", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                file,
+                symbol: symbol.id,
+            });
+            return (data ?? []).map(h => new NodeHandle(h, owner.project));
         });
-        return (data ?? []).map(h => new NodeHandle(h, this.project));
     }
     /** @deprecated Use `project.languageService.getReferencedSymbolsForNode`. */
-    getReferencedSymbolsForNode(node, position) {
-        return this.project.languageService.getReferencedSymbolsForNode(node, position);
+    get getReferencedSymbolsForNode() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getReferencedSymbolsForNode", function (node, position) {
+            return owner.project.languageService.getReferencedSymbolsForNode(node, position);
+        }, function* (node, position) {
+            return yield* owner.project.languageService.getReferencedSymbolsForNode.gen(node, position);
+        });
     }
     /** @deprecated Use `project.languageService.getSignatureUsage`. */
-    getSignatureUsage(signatureDecl) {
-        return this.project.languageService.getSignatureUsage(signatureDecl);
+    get getSignatureUsage() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getSignatureUsage", function (signatureDecl) {
+            return owner.project.languageService.getSignatureUsage(signatureDecl);
+        }, function* (signatureDecl) {
+            return yield* owner.project.languageService.getSignatureUsage.gen(signatureDecl);
+        });
     }
     /** @deprecated Use `project.languageService.getCompletionsAtPosition`. */
-    getCompletionsAtPosition(document, position, options) {
-        return this.project.languageService.getCompletionsAtPosition(document, position, options);
+    get getCompletionsAtPosition() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getCompletionsAtPosition", function (document, position, options) {
+            return owner.project.languageService.getCompletionsAtPosition(document, position, options);
+        }, function* (document, position, options) {
+            return yield* owner.project.languageService.getCompletionsAtPosition.gen(document, position, options);
+        });
     }
-    getTypeAtLocation(nodeOrNodes) {
-        if (Array.isArray(nodeOrNodes)) {
-            const data = this.client.apiRequest("getTypeAtLocations", {
-                snapshot: this.snapshotId,
-                project: this.project.id,
-                locations: nodeOrNodes.map(node => getNodeId(node)),
+    /**
+     * 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).
+     */
+    get getTypeAtLocation() {
+        const owner = this;
+        function getTypeAtLocation(nodeOrNodes) {
+            if (Array.isArray(nodeOrNodes)) {
+                const data = owner.client.apiRequest("getTypeAtLocations", {
+                    snapshot: owner.snapshotId,
+                    project: owner.project.id,
+                    locations: nodeOrNodes.map(node => getNodeId(node)),
+                });
+                return data.map(d => owner.objectRegistry.getOrCreateType(d));
+            }
+            const data = owner.client.apiRequest("getTypeAtLocation", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                location: getNodeId(nodeOrNodes),
             });
-            return data.map(d => this.objectRegistry.getOrCreateType(d));
+            return owner.objectRegistry.getOrCreateType(data);
         }
-        const data = this.client.apiRequest("getTypeAtLocation", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            location: getNodeId(nodeOrNodes),
-        });
-        return this.objectRegistry.getOrCreateType(data);
+        function* gen(nodeOrNodes) {
+            if (Array.isArray(nodeOrNodes)) {
+                const data = yield* apiRequest("getTypeAtLocations", {
+                    snapshot: owner.snapshotId,
+                    project: owner.project.id,
+                    locations: nodeOrNodes.map(node => getNodeId(node)),
+                });
+                return data.map(d => owner.objectRegistry.getOrCreateType(d));
+            }
+            const data = yield* apiRequest("getTypeAtLocation", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                location: getNodeId(nodeOrNodes),
+            });
+            return owner.objectRegistry.getOrCreateType(data);
+        }
+        return cacheGeneratorMethod(owner, "getTypeAtLocation", getTypeAtLocation, gen);
     }
-    getSignaturesOfType(type, kind) {
-        return kind === SignatureKind.Call ? type.getCallSignatures() : type.getConstructSignatures();
+    get getSignaturesOfType() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getSignaturesOfType", function (type, kind) {
+            return kind === SignatureKind.Call ? type.getCallSignatures() : type.getConstructSignatures();
+        }, function* (type, kind) {
+            return kind === SignatureKind.Call ? (yield* type.getCallSignatures.gen()) : (yield* type.getConstructSignatures.gen());
+        });
     }
     /**
      * 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) {
-        const data = this.client.apiRequest("getResolvedSignature", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            location: getNodeId(node),
-        });
-        return this.objectRegistry.getOrCreateSignature(data);
-    }
-    getTypeAtPosition(file, positionOrPositions) {
-        if (typeof positionOrPositions === "number") {
-            const data = this.client.apiRequest("getTypeAtPosition", {
-                snapshot: this.snapshotId,
-                project: this.project.id,
+    get getResolvedSignature() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getResolvedSignature", function (node) {
+            const data = owner.client.apiRequest("getResolvedSignature", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                location: getNodeId(node),
+            });
+            return owner.objectRegistry.getOrCreateSignature(data);
+        }, function* (node) {
+            const data = yield* apiRequest("getResolvedSignature", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                location: getNodeId(node),
+            });
+            return owner.objectRegistry.getOrCreateSignature(data);
+        });
+    }
+    get getTypeAtPosition() {
+        const owner = this;
+        function getTypeAtPosition(file, positionOrPositions) {
+            if (typeof positionOrPositions === "number") {
+                const data = owner.client.apiRequest("getTypeAtPosition", {
+                    snapshot: owner.snapshotId,
+                    project: owner.project.id,
+                    file,
+                    position: positionOrPositions,
+                });
+                return data ? owner.objectRegistry.getOrCreateType(data) : undefined;
+            }
+            const data = owner.client.apiRequest("getTypesAtPositions", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                file,
+                positions: positionOrPositions,
+            });
+            return data.map(d => d ? owner.objectRegistry.getOrCreateType(d) : undefined);
+        }
+        function* gen(file, positionOrPositions) {
+            if (typeof positionOrPositions === "number") {
+                const data = yield* apiRequest("getTypeAtPosition", {
+                    snapshot: owner.snapshotId,
+                    project: owner.project.id,
+                    file,
+                    position: positionOrPositions,
+                });
+                return data ? owner.objectRegistry.getOrCreateType(data) : undefined;
+            }
+            const data = yield* apiRequest("getTypesAtPositions", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
                 file,
-                position: positionOrPositions,
+                positions: positionOrPositions,
             });
-            return data ? this.objectRegistry.getOrCreateType(data) : undefined;
+            return data.map(d => d ? owner.objectRegistry.getOrCreateType(d) : undefined);
         }
-        const data = this.client.apiRequest("getTypesAtPositions", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            file,
-            positions: positionOrPositions,
-        });
-        return data.map(d => d ? this.objectRegistry.getOrCreateType(d) : undefined);
-    }
-    resolveName(name, meaning, location, excludeGlobals) {
-        // Distinguish Node (has `kind`) from DocumentPosition (has `document` and `position`)
-        const isNode = location && "kind" in location;
-        const data = this.client.apiRequest("resolveName", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            name,
-            meaning,
-            ...(isNode ? { location: getNodeId(location) } : {}),
-            ...(!isNode && location
-                ? {
-                    file: location.document,
-                    position: location.position,
-                }
-                : {}),
-            ...(excludeGlobals !== undefined ? { excludeGlobals } : {}),
+        return cacheGeneratorMethod(owner, "getTypeAtPosition", getTypeAtPosition, gen);
+    }
+    get resolveName() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "resolveName", function (name, meaning, location, excludeGlobals) {
+            // Distinguish Node (has `kind`) from DocumentPosition (has `document` and `position`)
+            const isNode = location && "kind" in location;
+            const data = owner.client.apiRequest("resolveName", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                name,
+                meaning,
+                ...(isNode ? { location: getNodeId(location) } : {}),
+                ...(!isNode && location
+                    ? {
+                        file: location.document,
+                        position: location.position,
+                    }
+                    : {}),
+                ...(excludeGlobals !== undefined ? { excludeGlobals } : {}),
+            });
+            return data ? owner.objectRegistry.getOrCreateSymbol(data) : undefined;
+        }, function* (name, meaning, location, excludeGlobals) {
+            // Distinguish Node (has `kind`) from DocumentPosition (has `document` and `position`)
+            const isNode = location && "kind" in location;
+            const data = yield* apiRequest("resolveName", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                name,
+                meaning,
+                ...(isNode ? { location: getNodeId(location) } : {}),
+                ...(!isNode && location
+                    ? {
+                        file: location.document,
+                        position: location.position,
+                    }
+                    : {}),
+                ...(excludeGlobals !== undefined ? { excludeGlobals } : {}),
+            });
+            return data ? owner.objectRegistry.getOrCreateSymbol(data) : undefined;
         });
-        return data ? this.objectRegistry.getOrCreateSymbol(data) : undefined;
     }
     /**
      * Returns all symbols with the given meaning that are visible at `location`.
      */
-    getSymbolsInScope(location, meaning) {
-        // Distinguish Node (has `kind`) from DocumentPosition (has `document` and `position`)
-        const isNode = "kind" in location;
-        const data = this.client.apiRequest("getSymbolsInScope", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            meaning,
-            ...(isNode
-                ? { location: getNodeId(location) }
-                : {
-                    file: location.document,
-                    position: location.position,
-                }),
-        });
-        return data ? data.map(d => this.objectRegistry.getOrCreateSymbol(d)) : [];
-    }
-    getResolvedSymbol(node) {
-        const text = node.text;
-        if (!text)
-            return undefined;
-        return this.resolveName(text, SymbolFlags.Value | SymbolFlags.ExportValue, node);
-    }
-    getContextualType(node) {
-        const data = this.client.apiRequest("getContextualType", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            location: getNodeId(node),
-        });
-        return data ? this.objectRegistry.getOrCreateType(data) : undefined;
+    get getSymbolsInScope() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getSymbolsInScope", function (location, meaning) {
+            // Distinguish Node (has `kind`) from DocumentPosition (has `document` and `position`)
+            const isNode = "kind" in location;
+            const data = owner.client.apiRequest("getSymbolsInScope", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                meaning,
+                ...(isNode
+                    ? { location: getNodeId(location) }
+                    : {
+                        file: location.document,
+                        position: location.position,
+                    }),
+            });
+            return data ? data.map(d => owner.objectRegistry.getOrCreateSymbol(d)) : [];
+        }, function* (location, meaning) {
+            // Distinguish Node (has `kind`) from DocumentPosition (has `document` and `position`)
+            const isNode = "kind" in location;
+            const data = yield* apiRequest("getSymbolsInScope", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                meaning,
+                ...(isNode
+                    ? { location: getNodeId(location) }
+                    : {
+                        file: location.document,
+                        position: location.position,
+                    }),
+            });
+            return data ? data.map(d => owner.objectRegistry.getOrCreateSymbol(d)) : [];
+        });
+    }
+    get getResolvedSymbol() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getResolvedSymbol", function (node) {
+            const text = node.text;
+            if (!text)
+                return undefined;
+            return owner.resolveName(text, SymbolFlags.Value | SymbolFlags.ExportValue, node);
+        }, function* (node) {
+            const text = node.text;
+            if (!text)
+                return undefined;
+            return yield* owner.resolveName.gen(text, SymbolFlags.Value | SymbolFlags.ExportValue, node);
+        });
+    }
+    get getContextualType() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getContextualType", function (node) {
+            const data = owner.client.apiRequest("getContextualType", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                location: getNodeId(node),
+            });
+            return data ? owner.objectRegistry.getOrCreateType(data) : undefined;
+        }, function* (node) {
+            const data = yield* apiRequest("getContextualType", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                location: getNodeId(node),
+            });
+            return data ? owner.objectRegistry.getOrCreateType(data) : undefined;
+        });
     }
     /** Get the base type of a literal type (e.g. `number` for `42`). Always returns a type. */
-    getBaseTypeOfLiteralType(type) {
-        const data = this.client.apiRequest("getBaseTypeOfLiteralType", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            type: type.id,
+    get getBaseTypeOfLiteralType() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getBaseTypeOfLiteralType", function (type) {
+            const data = owner.client.apiRequest("getBaseTypeOfLiteralType", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                type: type.id,
+            });
+            return owner.objectRegistry.getOrCreateType(data);
+        }, function* (type) {
+            const data = yield* apiRequest("getBaseTypeOfLiteralType", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                type: type.id,
+            });
+            return owner.objectRegistry.getOrCreateType(data);
         });
-        return this.objectRegistry.getOrCreateType(data);
     }
     /** Get the type with `null` and `undefined` removed. Always returns a type. */
-    getNonNullableType(type) {
-        return type.getNonNullableType();
+    get getNonNullableType() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getNonNullableType", function (type) {
+            return type.getNonNullableType();
+        }, function* (type) {
+            return yield* type.getNonNullableType.gen();
+        });
     }
     /**
      * 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) {
-        const data = this.client.apiRequest("getTypeFromTypeNode", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            location: getNodeId(node),
+    get getTypeFromTypeNode() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getTypeFromTypeNode", function (node) {
+            const data = owner.client.apiRequest("getTypeFromTypeNode", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                location: getNodeId(node),
+            });
+            return owner.objectRegistry.getOrCreateType(data);
+        }, function* (node) {
+            const data = yield* apiRequest("getTypeFromTypeNode", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                location: getNodeId(node),
+            });
+            return owner.objectRegistry.getOrCreateType(data);
         });
-        return this.objectRegistry.getOrCreateType(data);
     }
     /** Get the widened type. Always returns a type. */
-    getWidenedType(type) {
-        const data = this.client.apiRequest("getWidenedType", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            type: type.id,
+    get getWidenedType() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getWidenedType", function (type) {
+            const data = owner.client.apiRequest("getWidenedType", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                type: type.id,
+            });
+            return owner.objectRegistry.getOrCreateType(data);
+        }, function* (type) {
+            const data = yield* apiRequest("getWidenedType", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                type: type.id,
+            });
+            return owner.objectRegistry.getOrCreateType(data);
         });
-        return this.objectRegistry.getOrCreateType(data);
     }
     /**
      * 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, index) {
-        const data = this.client.apiRequest("getParameterType", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            signature: signature.id,
-            index,
+    get getParameterType() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getParameterType", function (signature, index) {
+            const data = owner.client.apiRequest("getParameterType", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                signature: signature.id,
+                index,
+            });
+            return owner.objectRegistry.getOrCreateType(data);
+        }, function* (signature, index) {
+            const data = yield* apiRequest("getParameterType", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                signature: signature.id,
+                index,
+            });
+            return owner.objectRegistry.getOrCreateType(data);
         });
-        return this.objectRegistry.getOrCreateType(data);
     }
-    isArrayLikeType(type) {
-        return this.client.apiRequest("isArrayLikeType", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            type: type.id,
+    get isArrayLikeType() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "isArrayLikeType", function (type) {
+            return owner.client.apiRequest("isArrayLikeType", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                type: type.id,
+            });
+        }, function* (type) {
+            return yield* apiRequest("isArrayLikeType", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                type: type.id,
+            });
         });
     }
-    isTypeAssignableTo(source, target) {
-        return this.client.apiRequest("isTypeAssignableTo", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            source: source.id,
-            target: target.id,
+    get isTypeAssignableTo() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "isTypeAssignableTo", function (source, target) {
+            return owner.client.apiRequest("isTypeAssignableTo", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                source: source.id,
+                target: target.id,
+            });
+        }, function* (source, target) {
+            return yield* apiRequest("isTypeAssignableTo", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                source: source.id,
+                target: target.id,
+            });
         });
     }
-    getShorthandAssignmentValueSymbol(node) {
-        const data = this.client.apiRequest("getShorthandAssignmentValueSymbol", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            location: getNodeId(node),
+    get getShorthandAssignmentValueSymbol() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getShorthandAssignmentValueSymbol", function (node) {
+            const data = owner.client.apiRequest("getShorthandAssignmentValueSymbol", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                location: getNodeId(node),
+            });
+            return data ? owner.objectRegistry.getOrCreateSymbol(data) : undefined;
+        }, function* (node) {
+            const data = yield* apiRequest("getShorthandAssignmentValueSymbol", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                location: getNodeId(node),
+            });
+            return data ? owner.objectRegistry.getOrCreateSymbol(data) : undefined;
         });
-        return data ? this.objectRegistry.getOrCreateSymbol(data) : undefined;
     }
     /**
      * Get the type of a symbol as narrowed at a specific location. Always returns
      * a type; for symbols whose type cannot be determined the checker yields the
      * error type (use {@link Type.isErrorType} to detect it).
      */
-    getTypeOfSymbolAtLocation(symbol, location) {
-        const data = this.client.apiRequest("getTypeOfSymbolAtLocation", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            symbol: symbol.id,
-            location: getNodeId(location),
-        });
-        return this.objectRegistry.getOrCreateType(data);
-    }
-    getIntrinsicType(method) {
-        const data = this.client.apiRequest(method, {
-            snapshot: this.snapshotId,
-            project: this.project.id,
+    get getTypeOfSymbolAtLocation() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getTypeOfSymbolAtLocation", function (symbol, location) {
+            const data = owner.client.apiRequest("getTypeOfSymbolAtLocation", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                symbol: symbol.id,
+                location: getNodeId(location),
+            });
+            return owner.objectRegistry.getOrCreateType(data);
+        }, function* (symbol, location) {
+            const data = yield* apiRequest("getTypeOfSymbolAtLocation", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                symbol: symbol.id,
+                location: getNodeId(location),
+            });
+            return owner.objectRegistry.getOrCreateType(data);
         });
-        return this.objectRegistry.getOrCreateType(data);
-    }
-    getAnyType() {
-        return this.getIntrinsicType("getAnyType");
-    }
-    getStringType() {
-        return this.getIntrinsicType("getStringType");
-    }
-    getNumberType() {
-        return this.getIntrinsicType("getNumberType");
-    }
-    getBooleanType() {
-        return this.getIntrinsicType("getBooleanType");
-    }
-    getVoidType() {
-        return this.getIntrinsicType("getVoidType");
-    }
-    getUndefinedType() {
-        return this.getIntrinsicType("getUndefinedType");
-    }
-    getNullType() {
-        return this.getIntrinsicType("getNullType");
-    }
-    getNeverType() {
-        return this.getIntrinsicType("getNeverType");
-    }
-    getUnknownType() {
-        return this.getIntrinsicType("getUnknownType");
-    }
-    getBigIntType() {
-        return this.getIntrinsicType("getBigIntType");
-    }
-    getESSymbolType() {
-        return this.getIntrinsicType("getESSymbolType");
     }
-    getNonPrimitiveType() {
-        return this.getIntrinsicType("getNonPrimitiveType");
-    }
-    typeToTypeNode(type, enclosingDeclaration, flags) {
-        const binaryData = this.client.apiRequestBinary("typeToTypeNode", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            type: type.id,
-            ...(enclosingDeclaration ? { location: getNodeId(enclosingDeclaration) } : {}),
-            ...(flags !== undefined ? { flags } : {}),
+    get getIntrinsicType() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getIntrinsicType", function (method) {
+            const data = owner.client.apiRequest(method, {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+            });
+            return owner.objectRegistry.getOrCreateType(data);
+        }, function* (method) {
+            const data = yield* apiRequest(method, {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+            });
+            return owner.objectRegistry.getOrCreateType(data);
         });
-        if (!binaryData)
-            return undefined;
-        return decodeNode(binaryData);
     }
-    signatureToSignatureDeclaration(signature, kind, enclosingDeclaration, flags) {
-        const binaryData = this.client.apiRequestBinary("signatureToSignatureDeclaration", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            signature: signature.id,
-            kind,
-            ...(enclosingDeclaration ? { location: getNodeId(enclosingDeclaration) } : {}),
-            ...(flags !== undefined ? { flags } : {}),
+    get getAnyType() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getAnyType", function () {
+            return owner.getIntrinsicType("getAnyType");
+        }, function* () {
+            return yield* owner.getIntrinsicType.gen("getAnyType");
+        });
+    }
+    get getStringType() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getStringType", function () {
+            return owner.getIntrinsicType("getStringType");
+        }, function* () {
+            return yield* owner.getIntrinsicType.gen("getStringType");
+        });
+    }
+    get getNumberType() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getNumberType", function () {
+            return owner.getIntrinsicType("getNumberType");
+        }, function* () {
+            return yield* owner.getIntrinsicType.gen("getNumberType");
+        });
+    }
+    get getBooleanType() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getBooleanType", function () {
+            return owner.getIntrinsicType("getBooleanType");
+        }, function* () {
+            return yield* owner.getIntrinsicType.gen("getBooleanType");
+        });
+    }
+    get getVoidType() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getVoidType", function () {
+            return owner.getIntrinsicType("getVoidType");
+        }, function* () {
+            return yield* owner.getIntrinsicType.gen("getVoidType");
+        });
+    }
+    get getUndefinedType() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getUndefinedType", function () {
+            return owner.getIntrinsicType("getUndefinedType");
+        }, function* () {
+            return yield* owner.getIntrinsicType.gen("getUndefinedType");
+        });
+    }
+    get getNullType() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getNullType", function () {
+            return owner.getIntrinsicType("getNullType");
+        }, function* () {
+            return yield* owner.getIntrinsicType.gen("getNullType");
+        });
+    }
+    get getNeverType() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getNeverType", function () {
+            return owner.getIntrinsicType("getNeverType");
+        }, function* () {
+            return yield* owner.getIntrinsicType.gen("getNeverType");
+        });
+    }
+    get getUnknownType() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getUnknownType", function () {
+            return owner.getIntrinsicType("getUnknownType");
+        }, function* () {
+            return yield* owner.getIntrinsicType.gen("getUnknownType");
+        });
+    }
+    get getBigIntType() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getBigIntType", function () {
+            return owner.getIntrinsicType("getBigIntType");
+        }, function* () {
+            return yield* owner.getIntrinsicType.gen("getBigIntType");
+        });
+    }
+    get getESSymbolType() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getESSymbolType", function () {
+            return owner.getIntrinsicType("getESSymbolType");
+        }, function* () {
+            return yield* owner.getIntrinsicType.gen("getESSymbolType");
+        });
+    }
+    get getNonPrimitiveType() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getNonPrimitiveType", function () {
+            return owner.getIntrinsicType("getNonPrimitiveType");
+        }, function* () {
+            return yield* owner.getIntrinsicType.gen("getNonPrimitiveType");
+        });
+    }
+    get typeToTypeNode() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "typeToTypeNode", function (type, enclosingDeclaration, flags) {
+            const binaryData = owner.client.apiRequestBinary("typeToTypeNode", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                type: type.id,
+                ...(enclosingDeclaration ? { location: getNodeId(enclosingDeclaration) } : {}),
+                ...(flags !== undefined ? { flags } : {}),
+            });
+            if (!binaryData)
+                return undefined;
+            return decodeNode(binaryData);
+        }, function* (type, enclosingDeclaration, flags) {
+            const binaryData = owner.client.apiRequestBinary("typeToTypeNode", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                type: type.id,
+                ...(enclosingDeclaration ? { location: getNodeId(enclosingDeclaration) } : {}),
+                ...(flags !== undefined ? { flags } : {}),
+            });
+            if (!binaryData)
+                return undefined;
+            return decodeNode(binaryData);
+        });
+    }
+    get signatureToSignatureDeclaration() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "signatureToSignatureDeclaration", function (signature, kind, enclosingDeclaration, flags) {
+            const binaryData = owner.client.apiRequestBinary("signatureToSignatureDeclaration", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                signature: signature.id,
+                kind,
+                ...(enclosingDeclaration ? { location: getNodeId(enclosingDeclaration) } : {}),
+                ...(flags !== undefined ? { flags } : {}),
+            });
+            if (!binaryData)
+                return undefined;
+            return decodeNode(binaryData);
+        }, function* (signature, kind, enclosingDeclaration, flags) {
+            const binaryData = owner.client.apiRequestBinary("signatureToSignatureDeclaration", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                signature: signature.id,
+                kind,
+                ...(enclosingDeclaration ? { location: getNodeId(enclosingDeclaration) } : {}),
+                ...(flags !== undefined ? { flags } : {}),
+            });
+            if (!binaryData)
+                return undefined;
+            return decodeNode(binaryData);
+        });
+    }
+    get typeToString() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "typeToString", function (type, enclosingDeclaration, flags) {
+            const result = owner.client.apiRequest("typeToString", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                type: type.id,
+                ...(enclosingDeclaration ? { location: getNodeId(enclosingDeclaration) } : {}),
+                ...(flags !== undefined ? { flags } : {}),
+            });
+            if (typeof result !== "string")
+                throw new TypeError("typeToString returned a non-string result");
+            return result;
+        }, function* (type, enclosingDeclaration, flags) {
+            const result = yield* apiRequest("typeToString", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                type: type.id,
+                ...(enclosingDeclaration ? { location: getNodeId(enclosingDeclaration) } : {}),
+                ...(flags !== undefined ? { flags } : {}),
+            });
+            if (typeof result !== "string")
+                throw new TypeError("typeToString returned a non-string result");
+            return result;
         });
-        if (!binaryData)
-            return undefined;
-        return decodeNode(binaryData);
     }
-    typeToString(type, enclosingDeclaration, flags) {
-        const result = this.client.apiRequest("typeToString", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            type: type.id,
-            ...(enclosingDeclaration ? { location: getNodeId(enclosingDeclaration) } : {}),
-            ...(flags !== undefined ? { flags } : {}),
+    get isContextSensitive() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "isContextSensitive", function (node) {
+            return owner.client.apiRequest("isContextSensitive", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                location: getNodeId(node),
+            });
+        }, function* (node) {
+            return yield* apiRequest("isContextSensitive", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                location: getNodeId(node),
+            });
         });
-        if (typeof result !== "string")
-            throw new TypeError("typeToString returned a non-string result");
-        return result;
     }
-    isContextSensitive(node) {
-        return this.client.apiRequest("isContextSensitive", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            location: getNodeId(node),
+    get isArrayType() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "isArrayType", function (type) {
+            return owner.client.apiRequest("isArrayType", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                type: type.id,
+            });
+        }, function* (type) {
+            return yield* apiRequest("isArrayType", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                type: type.id,
+            });
         });
     }
-    isArrayType(type) {
-        return this.client.apiRequest("isArrayType", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            type: type.id,
+    get isTupleType() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "isTupleType", function (type) {
+            return owner.client.apiRequest("isTupleType", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                type: type.id,
+            });
+        }, function* (type) {
+            return yield* apiRequest("isTupleType", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                type: type.id,
+            });
         });
     }
-    isTupleType(type) {
-        return this.client.apiRequest("isTupleType", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            type: type.id,
+    /**
+     * 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() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "isReadonlySymbol", function (symbol) {
+            return owner.client.apiRequest("isReadonlySymbol", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                symbol: symbol.id,
+            });
+        }, function* (symbol) {
+            return yield* apiRequest("isReadonlySymbol", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                symbol: symbol.id,
+            });
         });
     }
     /** Get the return type of a signature. Always returns a type. */
-    getReturnTypeOfSignature(signature) {
-        return signature.getReturnType();
+    get getReturnTypeOfSignature() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getReturnTypeOfSignature", function (signature) {
+            return signature.getReturnType();
+        }, function* (signature) {
+            return yield* signature.getReturnType.gen();
+        });
     }
     /**
      * Get the rest type of a signature. Always returns a type; a signature with
      * no rest parameter yields the `any` type.
      */
-    getRestTypeOfSignature(signature) {
-        const data = this.client.apiRequest("getRestTypeOfSignature", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            signature: signature.id,
-        });
-        return this.objectRegistry.getOrCreateType(data);
-    }
-    getTypePredicateOfSignature(signature) {
-        const data = this.client.apiRequest("getTypePredicateOfSignature", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            signature: signature.id,
-        });
-        if (!data)
-            return undefined;
-        return {
-            kind: data.kind,
-            parameterIndex: data.parameterIndex,
-            parameterName: data.parameterName,
-            type: data.type ? this.objectRegistry.getOrCreateType(data.type) : undefined,
-        };
+    get getRestTypeOfSignature() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getRestTypeOfSignature", function (signature) {
+            const data = owner.client.apiRequest("getRestTypeOfSignature", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                signature: signature.id,
+            });
+            return owner.objectRegistry.getOrCreateType(data);
+        }, function* (signature) {
+            const data = yield* apiRequest("getRestTypeOfSignature", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                signature: signature.id,
+            });
+            return owner.objectRegistry.getOrCreateType(data);
+        });
+    }
+    get getTypePredicateOfSignature() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getTypePredicateOfSignature", function (signature) {
+            const data = owner.client.apiRequest("getTypePredicateOfSignature", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                signature: signature.id,
+            });
+            if (!data)
+                return undefined;
+            return {
+                kind: data.kind,
+                parameterIndex: data.parameterIndex,
+                parameterName: data.parameterName,
+                type: data.type ? owner.objectRegistry.getOrCreateType(data.type) : undefined,
+            };
+        }, function* (signature) {
+            const data = yield* apiRequest("getTypePredicateOfSignature", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                signature: signature.id,
+            });
+            if (!data)
+                return undefined;
+            return {
+                kind: data.kind,
+                parameterIndex: data.parameterIndex,
+                parameterName: data.parameterName,
+                type: data.type ? owner.objectRegistry.getOrCreateType(data.type) : undefined,
+            };
+        });
     }
     /**
      * Get the base types of a class or interface type. A type with no base types
      * yields an empty array.
      */
-    getBaseTypes(type) {
-        return type.getBaseTypes() ?? [];
+    get getBaseTypes() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getBaseTypes", function (type) {
+            return type.getBaseTypes() ?? [];
+        }, function* (type) {
+            return (yield* type.getBaseTypes.gen()) ?? [];
+        });
     }
     /** Get the apparent type of a type. Always returns a type. */
-    getApparentType(type) {
-        return type.getApparentType();
+    get getApparentType() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getApparentType", function (type) {
+            return type.getApparentType();
+        }, function* (type) {
+            return yield* type.getApparentType.gen();
+        });
     }
     /** Get the reduced type of a type. Always returns a type. */
-    getReducedType(type) {
-        return type.getReducedType();
+    get getReducedType() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getReducedType", function (type) {
+            return type.getReducedType();
+        }, function* (type) {
+            return yield* type.getReducedType.gen();
+        });
     }
-    getPropertiesOfType(type) {
-        return type.getProperties();
+    get getPropertiesOfType() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getPropertiesOfType", function (type) {
+            return type.getProperties();
+        }, function* (type) {
+            return yield* type.getProperties.gen();
+        });
     }
-    getIndexInfosOfType(type) {
-        return type.getIndexInfos();
+    get getIndexInfosOfType() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getIndexInfosOfType", function (type) {
+            return type.getIndexInfos();
+        }, function* (type) {
+            return yield* type.getIndexInfos.gen();
+        });
     }
     /**
      * Get the constraint of a type parameter (the `T` in `<U extends T>`), or
      * undefined if it has none.
      */
-    getConstraintOfTypeParameter(type) {
-        return type.getConstraint();
-    }
-    getDefaultFromTypeParameter(type) {
-        return type.getDefault();
-    }
-    getBaseConstraintOfType(type) {
-        const data = this.client.apiRequest("getBaseConstraintOfType", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            type: type.id,
+    get getConstraintOfTypeParameter() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getConstraintOfTypeParameter", function (type) {
+            return type.getConstraint();
+        }, function* (type) {
+            return yield* type.getConstraint.gen();
+        });
+    }
+    get getDefaultFromTypeParameter() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getDefaultFromTypeParameter", function (type) {
+            return type.getDefault();
+        }, function* (type) {
+            return yield* type.getDefault.gen();
+        });
+    }
+    get getBaseConstraintOfType() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getBaseConstraintOfType", function (type) {
+            const data = owner.client.apiRequest("getBaseConstraintOfType", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                type: type.id,
+            });
+            return data ? owner.objectRegistry.getOrCreateType(data) : undefined;
+        }, function* (type) {
+            const data = yield* apiRequest("getBaseConstraintOfType", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                type: type.id,
+            });
+            return data ? owner.objectRegistry.getOrCreateType(data) : undefined;
         });
-        return data ? this.objectRegistry.getOrCreateType(data) : undefined;
     }
-    getPropertyOfType(type, name) {
-        const data = this.client.apiRequest("getPropertyOfType", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            type: type.id,
-            name,
+    get getPropertyOfType() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getPropertyOfType", function (type, name) {
+            const data = owner.client.apiRequest("getPropertyOfType", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                type: type.id,
+                name,
+            });
+            return data ? owner.objectRegistry.getOrCreateSymbol(data) : undefined;
+        }, function* (type, name) {
+            const data = yield* apiRequest("getPropertyOfType", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                type: type.id,
+                name,
+            });
+            return data ? owner.objectRegistry.getOrCreateSymbol(data) : undefined;
         });
-        return data ? this.objectRegistry.getOrCreateSymbol(data) : undefined;
     }
-    getConstantValue(node) {
-        const data = this.client.apiRequest("getConstantValue", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            location: getNodeId(node),
+    get getConstantValue() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getConstantValue", function (node) {
+            const data = owner.client.apiRequest("getConstantValue", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                location: getNodeId(node),
+            });
+            return typeof data === "string" || typeof data === "number" ? data : undefined;
+        }, function* (node) {
+            const data = yield* apiRequest("getConstantValue", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                location: getNodeId(node),
+            });
+            return typeof data === "string" || typeof data === "number" ? data : undefined;
         });
-        return typeof data === "string" || typeof data === "number" ? data : undefined;
     }
     /** Get the signature of a function-like declaration. Always returns a signature. */
-    getSignatureFromDeclaration(node) {
-        const data = this.client.apiRequest("getSignatureFromDeclaration", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            location: getNodeId(node),
+    get getSignatureFromDeclaration() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getSignatureFromDeclaration", function (node) {
+            const data = owner.client.apiRequest("getSignatureFromDeclaration", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                location: getNodeId(node),
+            });
+            return owner.objectRegistry.getOrCreateSignature(data);
+        }, function* (node) {
+            const data = yield* apiRequest("getSignatureFromDeclaration", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                location: getNodeId(node),
+            });
+            return owner.objectRegistry.getOrCreateSignature(data);
         });
-        return this.objectRegistry.getOrCreateSignature(data);
     }
-    getExportSpecifierLocalTargetSymbol(node) {
-        const data = this.client.apiRequest("getExportSpecifierLocalTargetSymbol", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            location: getNodeId(node),
+    get getExportSpecifierLocalTargetSymbol() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getExportSpecifierLocalTargetSymbol", function (node) {
+            const data = owner.client.apiRequest("getExportSpecifierLocalTargetSymbol", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                location: getNodeId(node),
+            });
+            return data ? owner.objectRegistry.getOrCreateSymbol(data) : undefined;
+        }, function* (node) {
+            const data = yield* apiRequest("getExportSpecifierLocalTargetSymbol", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                location: getNodeId(node),
+            });
+            return data ? owner.objectRegistry.getOrCreateSymbol(data) : undefined;
         });
-        return data ? this.objectRegistry.getOrCreateSymbol(data) : undefined;
     }
     /**
      * Follow all aliases to get the original symbol. Always returns a symbol; for
      * an unresolved alias the checker yields the unknown symbol (use
      * {@link Checker.isUnknownSymbol} to detect it).
      */
-    getAliasedSymbol(symbol) {
-        const data = this.client.apiRequest("getAliasedSymbol", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            symbol: symbol.id,
+    get getAliasedSymbol() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getAliasedSymbol", function (symbol) {
+            const data = owner.client.apiRequest("getAliasedSymbol", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                symbol: symbol.id,
+            });
+            return owner.objectRegistry.getOrCreateSymbol(data);
+        }, function* (symbol) {
+            const data = yield* apiRequest("getAliasedSymbol", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                symbol: symbol.id,
+            });
+            return owner.objectRegistry.getOrCreateSymbol(data);
         });
-        return this.objectRegistry.getOrCreateSymbol(data);
     }
     /**
      * Get the fully qualified name of a symbol, walking up its parent chain
      * (e.g. `"/path/to/module".Namespace.Name`).
      */
-    getFullyQualifiedName(symbol) {
-        return this.client.apiRequest("getFullyQualifiedName", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            symbol: symbol.id,
+    get getFullyQualifiedName() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getFullyQualifiedName", function (symbol) {
+            return owner.client.apiRequest("getFullyQualifiedName", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                symbol: symbol.id,
+            });
+        }, function* (symbol) {
+            return yield* apiRequest("getFullyQualifiedName", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                symbol: symbol.id,
+            });
+        });
+    }
+    get getImmediateAliasedSymbol() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getImmediateAliasedSymbol", function (symbol) {
+            const data = owner.client.apiRequest("getImmediateAliasedSymbol", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                symbol: symbol.id,
+            });
+            return data ? owner.objectRegistry.getOrCreateSymbol(data) : undefined;
+        }, function* (symbol) {
+            const data = yield* apiRequest("getImmediateAliasedSymbol", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                symbol: symbol.id,
+            });
+            return data ? owner.objectRegistry.getOrCreateSymbol(data) : undefined;
         });
     }
-    getImmediateAliasedSymbol(symbol) {
-        const data = this.client.apiRequest("getImmediateAliasedSymbol", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            symbol: symbol.id,
+    /**
+     * Get the target symbol if instantiated, or the provided symbol otherwise.
+     */
+    get getTargetSymbol() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getTargetSymbol", function (symbol) {
+            if (symbol.checkFlags & CheckFlags.Instantiated) {
+                const data = owner.client.apiRequest("getTargetSymbol", {
+                    snapshot: owner.snapshotId,
+                    project: owner.project.id,
+                    symbol: symbol.id,
+                });
+                return owner.objectRegistry.getOrCreateSymbol(data);
+            }
+            return symbol;
+        }, function* (symbol) {
+            if (symbol.checkFlags & CheckFlags.Instantiated) {
+                const data = yield* apiRequest("getTargetSymbol", {
+                    snapshot: owner.snapshotId,
+                    project: owner.project.id,
+                    symbol: symbol.id,
+                });
+                return owner.objectRegistry.getOrCreateSymbol(data);
+            }
+            return symbol;
         });
-        return data ? this.objectRegistry.getOrCreateSymbol(data) : undefined;
     }
     /**
      * Fetch (once, then cache) the handle ids of the per-checker singleton
@@ -1527,40 +2939,71 @@ export class Checker {
      * of the project's checker, so identity checks against them are local after
      * the first call.
      */
-    getWellKnownSymbols() {
-        return this.wellKnownSymbols ??= this.client.apiRequest("getWellKnownSymbols", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
+    get getWellKnownSymbols() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getWellKnownSymbols", function () {
+            return owner.wellKnownSymbols ??= owner.client.apiRequest("getWellKnownSymbols", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+            });
+        }, function* () {
+            return owner.wellKnownSymbols ??= yield* apiRequest("getWellKnownSymbols", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+            });
         });
     }
     /**
      * 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) {
-        return symbol.id === (this.getWellKnownSymbols()).unknown;
+    get isUnknownSymbol() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "isUnknownSymbol", function (symbol) {
+            return symbol.id === (owner.getWellKnownSymbols()).unknown;
+        }, function* (symbol) {
+            return symbol.id === (yield* owner.getWellKnownSymbols.gen()).unknown;
+        });
     }
     /**
      * Returns `true` if the symbol is the checker's "undefined" symbol.
      */
-    isUndefinedSymbol(symbol) {
-        return symbol.id === (this.getWellKnownSymbols()).undefined;
+    get isUndefinedSymbol() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "isUndefinedSymbol", function (symbol) {
+            return symbol.id === (owner.getWellKnownSymbols()).undefined;
+        }, function* (symbol) {
+            return symbol.id === (yield* owner.getWellKnownSymbols.gen()).undefined;
+        });
     }
     /**
      * Returns `true` if the symbol is the checker's "arguments" symbol.
      */
-    isArgumentsSymbol(symbol) {
-        return symbol.id === (this.getWellKnownSymbols()).arguments;
+    get isArgumentsSymbol() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "isArgumentsSymbol", function (symbol) {
+            return symbol.id === (owner.getWellKnownSymbols()).arguments;
+        }, function* (symbol) {
+            return symbol.id === (yield* owner.getWellKnownSymbols.gen()).arguments;
+        });
     }
     /**
      * 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.
      */
-    getWellKnownSignatures() {
-        return this.wellKnownSignatures ??= this.client.apiRequest("getWellKnownSignatures", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
+    get getWellKnownSignatures() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getWellKnownSignatures", function () {
+            return owner.wellKnownSignatures ??= owner.client.apiRequest("getWellKnownSignatures", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+            });
+        }, function* () {
+            return owner.wellKnownSignatures ??= yield* apiRequest("getWellKnownSignatures", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+            });
         });
     }
     /**
@@ -1568,51 +3011,106 @@ export class Checker {
      * the result of {@link Checker.getResolvedSignature} on a call that cannot be
      * resolved).
      */
-    isUnknownSignature(signature) {
-        return signature.id === (this.getWellKnownSignatures()).unknown;
-    }
-    getExportsOfModule(symbol) {
-        const data = this.client.apiRequest("getExportsOfModule", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            symbol: symbol.id,
+    get isUnknownSignature() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "isUnknownSignature", function (signature) {
+            return signature.id === (owner.getWellKnownSignatures()).unknown;
+        }, function* (signature) {
+            return signature.id === (yield* owner.getWellKnownSignatures.gen()).unknown;
+        });
+    }
+    get getExportsOfModule() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getExportsOfModule", function (symbol) {
+            const data = owner.client.apiRequest("getExportsOfModule", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                symbol: symbol.id,
+            });
+            return data ? data.map(d => owner.objectRegistry.getOrCreateSymbol(d)) : [];
+        }, function* (symbol) {
+            const data = yield* apiRequest("getExportsOfModule", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                symbol: symbol.id,
+            });
+            return data ? data.map(d => owner.objectRegistry.getOrCreateSymbol(d)) : [];
         });
-        return data ? data.map(d => this.objectRegistry.getOrCreateSymbol(d)) : [];
     }
-    getMemberInModuleExports(symbol, name) {
-        const data = this.client.apiRequest("getMemberInModuleExports", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            symbol: symbol.id,
-            name,
+    get getMemberInModuleExports() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getMemberInModuleExports", function (symbol, name) {
+            const data = owner.client.apiRequest("getMemberInModuleExports", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                symbol: symbol.id,
+                name,
+            });
+            return data ? owner.objectRegistry.getOrCreateSymbol(data) : undefined;
+        }, function* (symbol, name) {
+            const data = yield* apiRequest("getMemberInModuleExports", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                symbol: symbol.id,
+                name,
+            });
+            return data ? owner.objectRegistry.getOrCreateSymbol(data) : undefined;
         });
-        return data ? this.objectRegistry.getOrCreateSymbol(data) : undefined;
     }
-    getJsDocTagsOfSymbol(symbol) {
-        const data = this.client.apiRequest("getJsDocTags", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            symbol: symbol.id,
+    get getJsDocTagsOfSymbol() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getJsDocTagsOfSymbol", function (symbol) {
+            const data = owner.client.apiRequest("getJsDocTags", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                symbol: symbol.id,
+            });
+            return data ?? [];
+        }, function* (symbol) {
+            const data = yield* apiRequest("getJsDocTags", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                symbol: symbol.id,
+            });
+            return data ?? [];
         });
-        return data ?? [];
     }
-    getDocumentationCommentOfSymbol(symbol) {
-        return this.client.apiRequest("getDocumentationComment", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            symbol: symbol.id,
+    get getDocumentationCommentOfSymbol() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getDocumentationCommentOfSymbol", function (symbol) {
+            return owner.client.apiRequest("getDocumentationComment", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                symbol: symbol.id,
+            });
+        }, function* (symbol) {
+            return yield* apiRequest("getDocumentationComment", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                symbol: symbol.id,
+            });
         });
     }
     /**
      * Get the type arguments of a type reference (e.g. the `string` in `Array<string>`).
      */
-    getTypeArguments(type) {
-        const data = this.client.apiRequest("getTypeArguments", {
-            snapshot: this.snapshotId,
-            project: this.project.id,
-            type: type.id,
+    get getTypeArguments() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getTypeArguments", function (type) {
+            const data = owner.client.apiRequest("getTypeArguments", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                type: type.id,
+            });
+            return data ? data.map(d => owner.objectRegistry.getOrCreateType(d)) : [];
+        }, function* (type) {
+            const data = yield* apiRequest("getTypeArguments", {
+                snapshot: owner.snapshotId,
+                project: owner.project.id,
+                type: type.id,
+            });
+            return data ? data.map(d => owner.objectRegistry.getOrCreateType(d)) : [];
         });
-        return data ? data.map(d => this.objectRegistry.getOrCreateType(d)) : [];
     }
 }
 export class Emitter {
@@ -1620,14 +3118,26 @@ export class Emitter {
     constructor(client) {
         this.client = client;
     }
-    printNode(node, options = {}) {
-        const encoded = encodeNode(node);
-        const base64 = uint8ArrayToBase64(encoded);
-        return this.client.apiRequest("printNode", {
-            data: base64,
-            ...(options.preserveSourceNewlines !== undefined ? { preserveSourceNewlines: options.preserveSourceNewlines } : {}),
-            ...(options.neverAsciiEscape !== undefined ? { neverAsciiEscape: options.neverAsciiEscape } : {}),
-            ...(options.terminateUnterminatedLiterals !== undefined ? { terminateUnterminatedLiterals: options.terminateUnterminatedLiterals } : {}),
+    get printNode() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "printNode", function (node, options = {}) {
+            const encoded = encodeNode(node);
+            const base64 = uint8ArrayToBase64(encoded);
+            return owner.client.apiRequest("printNode", {
+                data: base64,
+                ...(options.preserveSourceNewlines !== undefined ? { preserveSourceNewlines: options.preserveSourceNewlines } : {}),
+                ...(options.neverAsciiEscape !== undefined ? { neverAsciiEscape: options.neverAsciiEscape } : {}),
+                ...(options.terminateUnterminatedLiterals !== undefined ? { terminateUnterminatedLiterals: options.terminateUnterminatedLiterals } : {}),
+            });
+        }, function* (node, options = {}) {
+            const encoded = encodeNode(node);
+            const base64 = uint8ArrayToBase64(encoded);
+            return yield* apiRequest("printNode", {
+                data: base64,
+                ...(options.preserveSourceNewlines !== undefined ? { preserveSourceNewlines: options.preserveSourceNewlines } : {}),
+                ...(options.neverAsciiEscape !== undefined ? { neverAsciiEscape: options.neverAsciiEscape } : {}),
+                ...(options.terminateUnterminatedLiterals !== undefined ? { terminateUnterminatedLiterals: options.terminateUnterminatedLiterals } : {}),
+            });
         });
     }
 }
@@ -1647,22 +3157,42 @@ export 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, file, position) {
-        const data = this.client.apiRequest("getDefaultProjectForFile", {
-            snapshot: this.snapshotId,
-            file,
-        });
-        if (!data) {
-            throw new Error(`No project found for file: ${typeof file === "string" ? file : file.uri}`);
-        }
-        const encoded = encodeNode(node);
-        const base64 = uint8ArrayToBase64(encoded);
-        return this.client.apiRequest("formatNodeForInsertion", {
-            snapshot: this.snapshotId,
-            project: data.id,
-            file,
-            position,
-            data: base64,
+    get formatNodeForInsertion() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "formatNodeForInsertion", function (node, file, position) {
+            const data = owner.client.apiRequest("getDefaultProjectForFile", {
+                snapshot: owner.snapshotId,
+                file,
+            });
+            if (!data) {
+                throw new Error(`No project found for file: ${typeof file === "string" ? file : file.uri}`);
+            }
+            const encoded = encodeNode(node);
+            const base64 = uint8ArrayToBase64(encoded);
+            return owner.client.apiRequest("formatNodeForInsertion", {
+                snapshot: owner.snapshotId,
+                project: data.id,
+                file,
+                position,
+                data: base64,
+            });
+        }, function* (node, file, position) {
+            const data = yield* apiRequest("getDefaultProjectForFile", {
+                snapshot: owner.snapshotId,
+                file,
+            });
+            if (!data) {
+                throw new Error(`No project found for file: ${typeof file === "string" ? file : file.uri}`);
+            }
+            const encoded = encodeNode(node);
+            const base64 = uint8ArrayToBase64(encoded);
+            return yield* apiRequest("formatNodeForInsertion", {
+                snapshot: owner.snapshotId,
+                project: data.id,
+                file,
+                position,
+                data: base64,
+            });
         });
     }
 }
@@ -1688,12 +3218,21 @@ export class NodeHandle {
      * and looking up the node by index. If no project is passed, the project that produced
      * the handle is used.
      */
-    resolve(project = this.canonicalProject) {
-        const sourceFile = project.program.getSourceFile(this.path);
-        if (!sourceFile) {
-            return undefined;
-        }
-        return sourceFile.getOrCreateNodeAtIndex(this.index);
+    get resolve() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "resolve", function (project = owner.canonicalProject) {
+            const sourceFile = project.program.getSourceFile(owner.path);
+            if (!sourceFile) {
+                return undefined;
+            }
+            return sourceFile.getOrCreateNodeAtIndex(owner.index);
+        }, function* (project = owner.canonicalProject) {
+            const sourceFile = yield* project.program.getSourceFile.gen(owner.path);
+            if (!sourceFile) {
+                return undefined;
+            }
+            return sourceFile.getOrCreateNodeAtIndex(owner.index);
+        });
     }
 }
 export class Symbol {
@@ -1736,41 +3275,83 @@ export class Symbol {
         if (data.exportSymbol !== undefined)
             this.exportSymbol = data.exportSymbol;
     }
-    getParent() {
-        return this.objectRegistry.fetchSymbol(this, "getParentOfSymbol", this.parent, this.canonicalProject.id);
+    get getParent() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getParent", function () {
+            return owner.objectRegistry.fetchSymbol(owner, "getParentOfSymbol", owner.parent, owner.canonicalProject.id);
+        }, function* () {
+            return yield* owner.objectRegistry.fetchSymbol.gen(owner, "getParentOfSymbol", owner.parent, owner.canonicalProject.id);
+        });
     }
     /**
      * 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() {
-        return this.membersCache ??= this.fetchSymbolTable("getMembersOfSymbol");
+    get getMembers() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getMembers", function () {
+            return owner.membersCache ??= owner.fetchSymbolTable("getMembersOfSymbol");
+        }, function* () {
+            return owner.membersCache ??= yield* owner.fetchSymbolTable.gen("getMembersOfSymbol");
+        });
     }
     /**
      * 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() {
-        return this.exportsCache ??= this.fetchSymbolTable("getExportsOfSymbol");
-    }
-    fetchSymbolTable(method) {
-        const symbols = this.objectRegistry.fetchSymbols(this, method, undefined, this.canonicalProject.id);
-        const table = new Map();
-        for (const symbol of symbols) {
-            table.set(symbol.escapedName, symbol);
-        }
-        return table;
+    get getExports() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getExports", function () {
+            return owner.exportsCache ??= owner.fetchSymbolTable("getExportsOfSymbol");
+        }, function* () {
+            return owner.exportsCache ??= yield* owner.fetchSymbolTable.gen("getExportsOfSymbol");
+        });
+    }
+    get fetchSymbolTable() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "fetchSymbolTable", function (method) {
+            const symbols = owner.objectRegistry.fetchSymbols(owner, method, undefined, owner.canonicalProject.id);
+            const table = new Map();
+            for (const symbol of symbols) {
+                table.set(symbol.escapedName, symbol);
+            }
+            return table;
+        }, function* (method) {
+            const symbols = yield* owner.objectRegistry.fetchSymbols.gen(owner, method, undefined, owner.canonicalProject.id);
+            const table = new Map();
+            for (const symbol of symbols) {
+                table.set(symbol.escapedName, symbol);
+            }
+            return table;
+        });
     }
-    getExportSymbol() {
-        if (!this.exportSymbol)
-            return this;
-        return this.objectRegistry.fetchSymbol(this, "getExportSymbolOfSymbol", this.exportSymbol, this.canonicalProject.id);
+    get getExportSymbol() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getExportSymbol", function () {
+            if (!owner.exportSymbol)
+                return owner;
+            return owner.objectRegistry.fetchSymbol(owner, "getExportSymbolOfSymbol", owner.exportSymbol, owner.canonicalProject.id);
+        }, function* () {
+            if (!owner.exportSymbol)
+                return owner;
+            return yield* owner.objectRegistry.fetchSymbol.gen(owner, "getExportSymbolOfSymbol", owner.exportSymbol, owner.canonicalProject.id);
+        });
     }
-    getJsDocTags(checker) {
-        return checker.getJsDocTagsOfSymbol(this);
+    get getJsDocTags() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getJsDocTags", function (checker) {
+            return checker.getJsDocTagsOfSymbol(owner);
+        }, function* (checker) {
+            return yield* checker.getJsDocTagsOfSymbol.gen(owner);
+        });
     }
-    getDocumentationComment(checker) {
-        return checker.getDocumentationCommentOfSymbol(this);
+    get getDocumentationComment() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getDocumentationComment", function (checker) {
+            return checker.getDocumentationCommentOfSymbol(owner);
+        }, function* (checker) {
+            return yield* checker.getDocumentationCommentOfSymbol.gen(owner);
+        });
     }
 }
 class TypeObject {
@@ -1888,162 +3469,381 @@ class TypeObject {
         this.stringIndexType = false;
         this.numberIndexType = false;
     }
-    getSymbol() {
-        return this.objectRegistry.fetchSymbol(this, "getSymbolOfType", this.symbol);
+    get getSymbol() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getSymbol", function () {
+            return owner.objectRegistry.fetchSymbol(owner, "getSymbolOfType", owner.symbol);
+        }, function* () {
+            return yield* owner.objectRegistry.fetchSymbol.gen(owner, "getSymbolOfType", owner.symbol);
+        });
     }
-    getProperties() {
-        if (this.properties === false) {
-            this.properties = this.objectRegistry.fetchPropertiesOfType(this);
-        }
-        return this.properties;
+    get getProperties() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getProperties", function () {
+            if (owner.properties === false) {
+                owner.properties = owner.objectRegistry.fetchPropertiesOfType(owner);
+            }
+            return owner.properties;
+        }, function* () {
+            if (owner.properties === false) {
+                owner.properties = yield* owner.objectRegistry.fetchPropertiesOfType.gen(owner);
+            }
+            return owner.properties;
+        });
     }
-    getProperty(propertyName) {
-        return this.objectRegistry.fetchPropertyOfType(this, propertyName);
+    get getProperty() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getProperty", function (propertyName) {
+            return owner.objectRegistry.fetchPropertyOfType(owner, propertyName);
+        }, function* (propertyName) {
+            return yield* owner.objectRegistry.fetchPropertyOfType.gen(owner, propertyName);
+        });
     }
-    getApparentProperties() {
-        if (this.apparentProperties === false) {
-            this.apparentProperties = this.objectRegistry.fetchApparentPropertiesOfType(this);
-        }
-        return this.apparentProperties;
+    get getApparentProperties() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getApparentProperties", function () {
+            if (owner.apparentProperties === false) {
+                owner.apparentProperties = owner.objectRegistry.fetchApparentPropertiesOfType(owner);
+            }
+            return owner.apparentProperties;
+        }, function* () {
+            if (owner.apparentProperties === false) {
+                owner.apparentProperties = yield* owner.objectRegistry.fetchApparentPropertiesOfType.gen(owner);
+            }
+            return owner.apparentProperties;
+        });
     }
-    getCallSignatures() {
-        if (this.callSignatures === false) {
-            this.callSignatures = this.objectRegistry.fetchSignaturesOfType(this, SignatureKind.Call);
-        }
-        return this.callSignatures;
+    get getCallSignatures() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getCallSignatures", function () {
+            if (owner.callSignatures === false) {
+                owner.callSignatures = owner.objectRegistry.fetchSignaturesOfType(owner, SignatureKind.Call);
+            }
+            return owner.callSignatures;
+        }, function* () {
+            if (owner.callSignatures === false) {
+                owner.callSignatures = yield* owner.objectRegistry.fetchSignaturesOfType.gen(owner, SignatureKind.Call);
+            }
+            return owner.callSignatures;
+        });
     }
-    getConstructSignatures() {
-        if (this.constructSignatures === false) {
-            this.constructSignatures = this.objectRegistry.fetchSignaturesOfType(this, SignatureKind.Construct);
-        }
-        return this.constructSignatures;
+    get getConstructSignatures() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getConstructSignatures", function () {
+            if (owner.constructSignatures === false) {
+                owner.constructSignatures = owner.objectRegistry.fetchSignaturesOfType(owner, SignatureKind.Construct);
+            }
+            return owner.constructSignatures;
+        }, function* () {
+            if (owner.constructSignatures === false) {
+                owner.constructSignatures = yield* owner.objectRegistry.fetchSignaturesOfType.gen(owner, SignatureKind.Construct);
+            }
+            return owner.constructSignatures;
+        });
     }
-    getNonNullableType() {
-        const result = this.objectRegistry.fetchType(this, "getNonNullableType", this.nonNullableType);
-        this.nonNullableType = result.id;
-        return result;
+    get getNonNullableType() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getNonNullableType", function () {
+            const result = owner.objectRegistry.fetchType(owner, "getNonNullableType", owner.nonNullableType);
+            owner.nonNullableType = result.id;
+            return result;
+        }, function* () {
+            const result = yield* owner.objectRegistry.fetchType.gen(owner, "getNonNullableType", owner.nonNullableType);
+            owner.nonNullableType = result.id;
+            return result;
+        });
     }
-    getStringIndexType() {
-        if (this.stringIndexType === false) {
-            this.stringIndexType = this.getStringIndexTypeWorker();
-        }
-        return this.stringIndexType;
+    get getStringIndexType() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getStringIndexType", function () {
+            if (owner.stringIndexType === false) {
+                owner.stringIndexType = owner.getStringIndexTypeWorker();
+            }
+            return owner.stringIndexType;
+        }, function* () {
+            if (owner.stringIndexType === false) {
+                owner.stringIndexType = yield* owner.getStringIndexTypeWorker.gen();
+            }
+            return owner.stringIndexType;
+        });
     }
-    getStringIndexTypeWorker() {
-        const infos = this.getIndexInfos();
-        return infos.find(info => (info.keyType.flags & TypeFlags.String) !== 0)?.valueType;
+    get getStringIndexTypeWorker() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getStringIndexTypeWorker", function () {
+            const infos = owner.getIndexInfos();
+            return infos.find(info => (info.keyType.flags & TypeFlags.String) !== 0)?.valueType;
+        }, function* () {
+            const infos = yield* owner.getIndexInfos.gen();
+            return infos.find(info => (info.keyType.flags & TypeFlags.String) !== 0)?.valueType;
+        });
     }
-    getNumberIndexType() {
-        if (this.numberIndexType === false) {
-            this.numberIndexType = this.getNumberIndexTypeWorker();
-        }
-        return this.numberIndexType;
+    get getNumberIndexType() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getNumberIndexType", function () {
+            if (owner.numberIndexType === false) {
+                owner.numberIndexType = owner.getNumberIndexTypeWorker();
+            }
+            return owner.numberIndexType;
+        }, function* () {
+            if (owner.numberIndexType === false) {
+                owner.numberIndexType = yield* owner.getNumberIndexTypeWorker.gen();
+            }
+            return owner.numberIndexType;
+        });
     }
-    getNumberIndexTypeWorker() {
-        const infos = this.getIndexInfos();
-        return infos.find(info => (info.keyType.flags & TypeFlags.Number) !== 0)?.valueType;
+    get getNumberIndexTypeWorker() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getNumberIndexTypeWorker", function () {
+            const infos = owner.getIndexInfos();
+            return infos.find(info => (info.keyType.flags & TypeFlags.Number) !== 0)?.valueType;
+        }, function* () {
+            const infos = yield* owner.getIndexInfos.gen();
+            return infos.find(info => (info.keyType.flags & TypeFlags.Number) !== 0)?.valueType;
+        });
     }
-    getApparentType() {
-        const result = this.objectRegistry.fetchType(this, "getApparentType", this.apparentType);
-        this.apparentType = result.id;
-        return result;
+    get getApparentType() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getApparentType", function () {
+            const result = owner.objectRegistry.fetchType(owner, "getApparentType", owner.apparentType);
+            owner.apparentType = result.id;
+            return result;
+        }, function* () {
+            const result = yield* owner.objectRegistry.fetchType.gen(owner, "getApparentType", owner.apparentType);
+            owner.apparentType = result.id;
+            return result;
+        });
     }
-    getReducedType() {
-        const result = this.objectRegistry.fetchType(this, "getReducedType", this.reducedType);
-        this.reducedType = result.id;
-        return result;
+    get getReducedType() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getReducedType", function () {
+            const result = owner.objectRegistry.fetchType(owner, "getReducedType", owner.reducedType);
+            owner.reducedType = result.id;
+            return result;
+        }, function* () {
+            const result = yield* owner.objectRegistry.fetchType.gen(owner, "getReducedType", owner.reducedType);
+            owner.reducedType = result.id;
+            return result;
+        });
     }
-    getIndexInfos() {
-        if (this.indexInfos === false) {
-            this.indexInfos = this.objectRegistry.fetchIndexInfosOfType(this);
-        }
-        return this.indexInfos;
+    get getIndexInfos() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getIndexInfos", function () {
+            if (owner.indexInfos === false) {
+                owner.indexInfos = owner.objectRegistry.fetchIndexInfosOfType(owner);
+            }
+            return owner.indexInfos;
+        }, function* () {
+            if (owner.indexInfos === false) {
+                owner.indexInfos = yield* owner.objectRegistry.fetchIndexInfosOfType.gen(owner);
+            }
+            return owner.indexInfos;
+        });
     }
-    getAliasSymbol() {
-        return this.objectRegistry.fetchSymbol(this, "getAliasSymbolOfType", this.aliasSymbol);
+    get getAliasSymbol() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getAliasSymbol", function () {
+            return owner.objectRegistry.fetchSymbol(owner, "getAliasSymbolOfType", owner.aliasSymbol);
+        }, function* () {
+            return yield* owner.objectRegistry.fetchSymbol.gen(owner, "getAliasSymbolOfType", owner.aliasSymbol);
+        });
     }
-    getTarget() {
-        return this.objectRegistry.fetchType(this, "getTargetOfType", this.target);
+    get getTarget() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getTarget", function () {
+            return owner.objectRegistry.fetchType(owner, "getTargetOfType", owner.target);
+        }, function* () {
+            return yield* owner.objectRegistry.fetchType.gen(owner, "getTargetOfType", owner.target);
+        });
     }
-    getFreshType() {
-        return this.objectRegistry.fetchOptionalType(this, "getFreshTypeOfType", this.freshType);
+    get getFreshType() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getFreshType", function () {
+            return owner.objectRegistry.fetchOptionalType(owner, "getFreshTypeOfType", owner.freshType);
+        }, function* () {
+            return yield* owner.objectRegistry.fetchOptionalType.gen(owner, "getFreshTypeOfType", owner.freshType);
+        });
     }
-    getRegularType() {
-        return this.objectRegistry.fetchOptionalType(this, "getRegularTypeOfType", this.regularType);
+    get getRegularType() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getRegularType", function () {
+            return owner.objectRegistry.fetchOptionalType(owner, "getRegularTypeOfType", owner.regularType);
+        }, function* () {
+            return yield* owner.objectRegistry.fetchOptionalType.gen(owner, "getRegularTypeOfType", owner.regularType);
+        });
     }
-    getTypes() {
-        // Only union, intersection, and template literal types have constituent
-        // types; any other kind has none, so return undefined rather than sending
-        // a request the server cannot satisfy.
-        if (!(this.flags & (TypeFlags.UnionOrIntersection | TypeFlags.TemplateLiteral))) {
-            return undefined;
-        }
-        return this.objectRegistry.fetchTypes(this, "getTypesOfType");
+    get getTypes() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getTypes", function () {
+            // Only union, intersection, and template literal types have constituent
+            // types; any other kind has none, so return undefined rather than sending
+            // a request the server cannot satisfy.
+            if (!(owner.flags & (TypeFlags.UnionOrIntersection | TypeFlags.TemplateLiteral))) {
+                return undefined;
+            }
+            return owner.objectRegistry.fetchTypes(owner, "getTypesOfType");
+        }, function* () {
+            // Only union, intersection, and template literal types have constituent
+            // types; any other kind has none, so return undefined rather than sending
+            // a request the server cannot satisfy.
+            if (!(owner.flags & (TypeFlags.UnionOrIntersection | TypeFlags.TemplateLiteral))) {
+                return undefined;
+            }
+            return yield* owner.objectRegistry.fetchTypes.gen(owner, "getTypesOfType");
+        });
     }
-    getTypeParameters() {
-        return this.objectRegistry.fetchTypes(this, "getTypeParametersOfType", this.typeParameters);
+    get getTypeParameters() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getTypeParameters", function () {
+            return owner.objectRegistry.fetchTypes(owner, "getTypeParametersOfType", owner.typeParameters);
+        }, function* () {
+            return (yield* owner.objectRegistry.fetchTypes.gen(owner, "getTypeParametersOfType", owner.typeParameters));
+        });
     }
-    getOuterTypeParameters() {
-        return this.objectRegistry.fetchTypes(this, "getOuterTypeParametersOfType", this.outerTypeParameters);
+    get getOuterTypeParameters() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getOuterTypeParameters", function () {
+            return owner.objectRegistry.fetchTypes(owner, "getOuterTypeParametersOfType", owner.outerTypeParameters);
+        }, function* () {
+            return (yield* owner.objectRegistry.fetchTypes.gen(owner, "getOuterTypeParametersOfType", owner.outerTypeParameters));
+        });
     }
-    getLocalTypeParameters() {
-        return this.objectRegistry.fetchTypes(this, "getLocalTypeParametersOfType", this.localTypeParameters);
+    get getLocalTypeParameters() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getLocalTypeParameters", function () {
+            return owner.objectRegistry.fetchTypes(owner, "getLocalTypeParametersOfType", owner.localTypeParameters);
+        }, function* () {
+            return (yield* owner.objectRegistry.fetchTypes.gen(owner, "getLocalTypeParametersOfType", owner.localTypeParameters));
+        });
     }
-    getAliasTypeArguments() {
-        return this.objectRegistry.fetchTypes(this, "getAliasTypeArgumentsOfType", this.aliasTypeArguments);
+    get getAliasTypeArguments() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getAliasTypeArguments", function () {
+            return owner.objectRegistry.fetchTypes(owner, "getAliasTypeArgumentsOfType", owner.aliasTypeArguments);
+        }, function* () {
+            return yield* owner.objectRegistry.fetchTypes.gen(owner, "getAliasTypeArgumentsOfType", owner.aliasTypeArguments);
+        });
     }
-    getObjectType() {
-        return this.objectRegistry.fetchType(this, "getObjectTypeOfType", this.objectType);
+    get getObjectType() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getObjectType", function () {
+            return owner.objectRegistry.fetchType(owner, "getObjectTypeOfType", owner.objectType);
+        }, function* () {
+            return yield* owner.objectRegistry.fetchType.gen(owner, "getObjectTypeOfType", owner.objectType);
+        });
     }
-    getIndexType() {
-        return this.objectRegistry.fetchType(this, "getIndexTypeOfType", this.indexType);
+    get getIndexType() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getIndexType", function () {
+            return owner.objectRegistry.fetchType(owner, "getIndexTypeOfType", owner.indexType);
+        }, function* () {
+            return yield* owner.objectRegistry.fetchType.gen(owner, "getIndexTypeOfType", owner.indexType);
+        });
     }
-    getCheckType() {
-        return this.objectRegistry.fetchType(this, "getCheckTypeOfType", this.checkType);
+    get getCheckType() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getCheckType", function () {
+            return owner.objectRegistry.fetchType(owner, "getCheckTypeOfType", owner.checkType);
+        }, function* () {
+            return yield* owner.objectRegistry.fetchType.gen(owner, "getCheckTypeOfType", owner.checkType);
+        });
     }
-    getExtendsType() {
-        return this.objectRegistry.fetchType(this, "getExtendsTypeOfType", this.extendsType);
+    get getExtendsType() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getExtendsType", function () {
+            return owner.objectRegistry.fetchType(owner, "getExtendsTypeOfType", owner.extendsType);
+        }, function* () {
+            return yield* owner.objectRegistry.fetchType.gen(owner, "getExtendsTypeOfType", owner.extendsType);
+        });
     }
-    getBaseType() {
-        return this.objectRegistry.fetchType(this, "getBaseTypeOfType", this.baseType);
+    get getBaseType() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getBaseType", function () {
+            return owner.objectRegistry.fetchType(owner, "getBaseTypeOfType", owner.baseType);
+        }, function* () {
+            return yield* owner.objectRegistry.fetchType.gen(owner, "getBaseTypeOfType", owner.baseType);
+        });
     }
-    getConstraint() {
-        // Type parameters resolve their constraint lazily through the checker,
-        // whereas substitution types carry a preloaded constraint handle.
-        if (this.flags & TypeFlags.TypeParameter) {
-            const result = this.objectRegistry.fetchOptionalType(this, "getConstraintOfTypeParameter", this.constraint);
-            this.constraint = result ? result.id : 0;
-            return result;
-        }
-        return this.objectRegistry.fetchType(this, "getConstraintOfType", this.substConstraint);
+    get getConstraint() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getConstraint", function () {
+            // Type parameters resolve their constraint lazily through the checker,
+            // whereas substitution types carry a preloaded constraint handle.
+            if (owner.flags & TypeFlags.TypeParameter) {
+                const result = owner.objectRegistry.fetchOptionalType(owner, "getConstraintOfTypeParameter", owner.constraint);
+                owner.constraint = result ? result.id : 0;
+                return result;
+            }
+            return owner.objectRegistry.fetchType(owner, "getConstraintOfType", owner.substConstraint);
+        }, function* () {
+            // Type parameters resolve their constraint lazily through the checker,
+            // whereas substitution types carry a preloaded constraint handle.
+            if (owner.flags & TypeFlags.TypeParameter) {
+                const result = yield* owner.objectRegistry.fetchOptionalType.gen(owner, "getConstraintOfTypeParameter", owner.constraint);
+                owner.constraint = result ? result.id : 0;
+                return result;
+            }
+            return yield* owner.objectRegistry.fetchType.gen(owner, "getConstraintOfType", owner.substConstraint);
+        });
     }
-    getDefault() {
-        const result = this.objectRegistry.fetchOptionalType(this, "getDefaultFromTypeParameter", this.default);
-        this.default = result ? result.id : 0;
-        return result;
+    get getDefault() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getDefault", function () {
+            const result = owner.objectRegistry.fetchOptionalType(owner, "getDefaultFromTypeParameter", owner.default);
+            owner.default = result ? result.id : 0;
+            return result;
+        }, function* () {
+            const result = yield* owner.objectRegistry.fetchOptionalType.gen(owner, "getDefaultFromTypeParameter", owner.default);
+            owner.default = result ? result.id : 0;
+            return result;
+        });
     }
-    getTrueType() {
-        const result = this.objectRegistry.fetchType(this, "getTrueTypeOfConditionalType", this.trueType);
-        this.trueType = result.id;
-        return result;
+    get getTrueType() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getTrueType", function () {
+            const result = owner.objectRegistry.fetchType(owner, "getTrueTypeOfConditionalType", owner.trueType);
+            owner.trueType = result.id;
+            return result;
+        }, function* () {
+            const result = yield* owner.objectRegistry.fetchType.gen(owner, "getTrueTypeOfConditionalType", owner.trueType);
+            owner.trueType = result.id;
+            return result;
+        });
     }
-    getFalseType() {
-        const result = this.objectRegistry.fetchType(this, "getFalseTypeOfConditionalType", this.falseType);
-        this.falseType = result.id;
-        return result;
+    get getFalseType() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getFalseType", function () {
+            const result = owner.objectRegistry.fetchType(owner, "getFalseTypeOfConditionalType", owner.falseType);
+            owner.falseType = result.id;
+            return result;
+        }, function* () {
+            const result = yield* owner.objectRegistry.fetchType.gen(owner, "getFalseTypeOfConditionalType", owner.falseType);
+            owner.falseType = result.id;
+            return result;
+        });
     }
     /**
      * Get the base types of this type. Returns `undefined` for any type that is
      * not a class or interface.
      */
-    getBaseTypes() {
-        if (!this.isClassOrInterface()) {
-            return undefined;
-        }
-        if (this.baseTypes === false) {
-            this.baseTypes = this.objectRegistry.fetchBaseTypes(this);
-        }
-        return this.baseTypes;
+    get getBaseTypes() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getBaseTypes", function () {
+            if (!owner.isClassOrInterface()) {
+                return undefined;
+            }
+            if (owner.baseTypes === false) {
+                owner.baseTypes = owner.objectRegistry.fetchBaseTypes(owner);
+            }
+            return owner.baseTypes;
+        }, function* () {
+            if (!owner.isClassOrInterface()) {
+                return undefined;
+            }
+            if (owner.baseTypes === false) {
+                owner.baseTypes = yield* owner.objectRegistry.fetchBaseTypes.gen(owner);
+            }
+            return owner.baseTypes;
+        });
     }
     isClassOrInterface() {
         return isClassOrInterfaceType(this);
@@ -2193,25 +3993,57 @@ export class Signature {
         this.target = data.target;
         this.returnType = false;
     }
-    getTypeParameters() {
-        return this.objectRegistry.fetchTypes(this, "getTypeParametersOfSignature", this.typeParameters);
+    get getTypeParameters() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getTypeParameters", function () {
+            return owner.objectRegistry.fetchTypes(owner, "getTypeParametersOfSignature", owner.typeParameters);
+        }, function* () {
+            return (yield* owner.objectRegistry.fetchTypes.gen(owner, "getTypeParametersOfSignature", owner.typeParameters));
+        });
     }
-    getParameters() {
-        return this.objectRegistry.fetchSymbols(this, "getParametersOfSignature", this.parameters);
+    get getParameters() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getParameters", function () {
+            return owner.objectRegistry.fetchSymbols(owner, "getParametersOfSignature", owner.parameters);
+        }, function* () {
+            return yield* owner.objectRegistry.fetchSymbols.gen(owner, "getParametersOfSignature", owner.parameters);
+        });
     }
-    getThisParameter() {
-        return this.objectRegistry.fetchSymbol(this, "getThisParameterOfSignature", this.thisParameter);
+    get getThisParameter() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getThisParameter", function () {
+            return owner.objectRegistry.fetchSymbol(owner, "getThisParameterOfSignature", owner.thisParameter);
+        }, function* () {
+            return yield* owner.objectRegistry.fetchSymbol.gen(owner, "getThisParameterOfSignature", owner.thisParameter);
+        });
     }
-    getTarget() {
-        return this.objectRegistry.fetchSignature(this, "getTargetOfSignature", this.target);
+    get getTarget() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getTarget", function () {
+            return owner.objectRegistry.fetchSignature(owner, "getTargetOfSignature", owner.target);
+        }, function* () {
+            return yield* owner.objectRegistry.fetchSignature.gen(owner, "getTargetOfSignature", owner.target);
+        });
     }
-    getReturnType() {
-        const result = this.objectRegistry.fetchType(this, "getReturnTypeOfSignature", this.returnType);
-        this.returnType = result.id;
-        return result;
+    get getReturnType() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getReturnType", function () {
+            const result = owner.objectRegistry.fetchType(owner, "getReturnTypeOfSignature", owner.returnType);
+            owner.returnType = result.id;
+            return result;
+        }, function* () {
+            const result = yield* owner.objectRegistry.fetchType.gen(owner, "getReturnTypeOfSignature", owner.returnType);
+            owner.returnType = result.id;
+            return result;
+        });
     }
-    getTypeParameterAtPosition(pos) {
-        return this.objectRegistry.fetchTypeParameterAtPosition(this, pos);
+    get getTypeParameterAtPosition() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "getTypeParameterAtPosition", function (pos) {
+            return owner.objectRegistry.fetchTypeParameterAtPosition(owner, pos);
+        }, function* (pos) {
+            return yield* owner.objectRegistry.fetchTypeParameterAtPosition.gen(owner, pos);
+        });
     }
     get hasRestParameter() {
         return (this.flags & SignatureFlags.HasRestParameter) !== 0;