@codingame/monaco-vscode-api 20.1.1 → 20.2.0

package/vscode/src/vs/platform/workspace/common/workspace.d.ts

@@ -4,16 +4,44 @@ export interface IResolvedWorkspace extends IWorkspaceIdentifier, IBaseWorkspace
     readonly folders: IWorkspaceFolder[];
 }
 export interface IBaseWorkspace {
+    /**
+     * If present, marks the window that opens the workspace
+     * as a remote window with the given authority.
+     */
     readonly remoteAuthority?: string;
+    /**
+     * Transient workspaces are meant to go away after being used
+     * once, e.g. a window reload of a transient workspace will
+     * open an empty window.
+     *
+     * See: https://github.com/microsoft/vscode/issues/119695
+     */
     readonly transient?: boolean;
 }
 export interface IBaseWorkspaceIdentifier {
+    /**
+     * Every workspace (multi-root, single folder or empty)
+     * has a unique identifier. It is not possible to open
+     * a workspace with the same `id` in multiple windows
+     */
     readonly id: string;
 }
+/**
+ * A single folder workspace identifier is a path to a folder + id.
+ */
 export interface ISingleFolderWorkspaceIdentifier extends IBaseWorkspaceIdentifier {
+    /**
+     * Folder path as `URI`.
+     */
     readonly uri: URI;
 }
+/**
+ * A multi-root workspace identifier is a path to a workspace file + id.
+ */
 export interface IWorkspaceIdentifier extends IBaseWorkspaceIdentifier {
+    /**
+     * Workspace config file path as `URI`.
+     */
     configPath: URI;
 }
 export interface IEmptyWorkspaceIdentifier extends IBaseWorkspaceIdentifier {
@@ -53,18 +81,45 @@ export interface IWorkspaceFoldersChangeEvent {
     changed: IWorkspaceFolder[];
 }
 export interface IWorkspace {
+    /**
+     * the unique identifier of the workspace.
+     */
     readonly id: string;
+    /**
+     * Folders in the workspace.
+     */
     readonly folders: IWorkspaceFolder[];
+    /**
+     * Transient workspaces are meant to go away after being used
+     * once, e.g. a window reload of a transient workspace will
+     * open an empty window.
+     */
     readonly transient?: boolean;
+    /**
+     * the location of the workspace configuration
+     */
     readonly configuration?: URI | null;
 }
 export declare function isWorkspace(thing: unknown): thing is IWorkspace;
 export interface IWorkspaceFolderData {
+    /**
+     * The associated URI for this workspace folder.
+     */
     readonly uri: URI;
+    /**
+     * The name of this workspace folder. Defaults to
+     * the basename of its [uri-path](#Uri.path)
+     */
     readonly name: string;
+    /**
+     * The ordinal number of this workspace folder.
+     */
     readonly index: number;
 }
 export interface IWorkspaceFolder extends IWorkspaceFolderData {
+    /**
+     * Given workspace folder relative path, returns the resource with the absolute path.
+     */
     toResource: (relativePath: string) => URI;
 }
 export declare function isWorkspaceFolder(thing: unknown): thing is IWorkspaceFolder;
@@ -96,11 +151,26 @@ export interface IRawUriWorkspaceFolder {
     name?: string;
 }
 export declare class WorkspaceFolder implements IWorkspaceFolder {
+    /**
+     * Provides access to the original metadata for this workspace
+     * folder. This can be different from the metadata provided in
+     * this class:
+     * - raw paths can be relative
+     * - raw paths are not normalized
+     */
     readonly raw?: (IRawFileWorkspaceFolder | IRawUriWorkspaceFolder) | undefined;
     readonly uri: URI;
     readonly name: string;
     readonly index: number;
-    constructor(data: IWorkspaceFolderData, raw?: (IRawFileWorkspaceFolder | IRawUriWorkspaceFolder) | undefined);
+    constructor(data: IWorkspaceFolderData, 
+    /**
+     * Provides access to the original metadata for this workspace
+     * folder. This can be different from the metadata provided in
+     * this class:
+     * - raw paths can be relative
+     * - raw paths are not normalized
+     */
+    raw?: (IRawFileWorkspaceFolder | IRawUriWorkspaceFolder) | undefined);
     toResource(relativePath: string): URI;
     toJSON(): IWorkspaceFolderData;
 }

package/vscode/src/vs/platform/workspace/common/workspace.service.d.ts

@@ -4,14 +4,50 @@ import { WorkbenchState, IWorkspaceFoldersWillChangeEvent, IWorkspaceFoldersChan
 export declare const IWorkspaceContextService: import("../../instantiation/common/instantiation.js").ServiceIdentifier<IWorkspaceContextService>;
 export interface IWorkspaceContextService {
     readonly _serviceBrand: undefined;
+    /**
+    * An event which fires on workbench state changes.
+    */
     readonly onDidChangeWorkbenchState: Event<WorkbenchState>;
+    /**
+    * An event which fires on workspace name changes.
+    */
     readonly onDidChangeWorkspaceName: Event<void>;
+    /**
+    * An event which fires before workspace folders change.
+    */
     readonly onWillChangeWorkspaceFolders: Event<IWorkspaceFoldersWillChangeEvent>;
+    /**
+    * An event which fires on workspace folders change.
+    */
     readonly onDidChangeWorkspaceFolders: Event<IWorkspaceFoldersChangeEvent>;
+    /**
+    * Provides access to the complete workspace object.
+    */
     getCompleteWorkspace(): Promise<IWorkspace>;
+    /**
+    * Provides access to the workspace object the window is running with.
+    * Use `getCompleteWorkspace` to get complete workspace object.
+    */
     getWorkspace(): IWorkspace;
+    /**
+    * Return the state of the workbench.
+    *
+    * WorkbenchState.EMPTY - if the workbench was opened with empty window or file
+    * WorkbenchState.FOLDER - if the workbench was opened with a folder
+    * WorkbenchState.WORKSPACE - if the workbench was opened with a workspace
+    */
     getWorkbenchState(): WorkbenchState;
+    /**
+    * Returns the folder for the given resource from the workspace.
+    * Can be null if there is no workspace or the resource is not inside the workspace.
+    */
     getWorkspaceFolder(resource: URI): IWorkspaceFolder | null;
+    /**
+    * Return `true` if the current workspace has the given identifier or root URI otherwise `false`.
+    */
     isCurrentWorkspace(workspaceIdOrFolder: IWorkspaceIdentifier | ISingleFolderWorkspaceIdentifier | URI): boolean;
+    /**
+    * Returns if the provided resource is inside the workspace or not.
+    */
     isInsideWorkspace(resource: URI): boolean;
 }

package/vscode/src/vs/workbench/api/common/extHost.api.impl.d.ts

@@ -10,4 +10,7 @@ export interface IExtensionRegistries {
 export interface IExtensionApiFactory {
     (extension: IExtensionDescription, extensionInfo: IExtensionRegistries, configProvider: ExtHostConfigProvider): typeof vscode;
 }
+/**
+ * This method instantiates and returns the extension API surface
+ */
 export declare function createApiFactoryAndRegisterActors(accessor: ServicesAccessor): IExtensionApiFactory;

package/vscode/src/vs/workbench/api/common/extHost.protocol.d.ts

@@ -525,6 +525,14 @@ export interface MainThreadProgressShape extends IDisposable {
     $progressReport(handle: number, message: IProgressStep): void;
     $progressEnd(handle: number): void;
 }
+/**
+ * A terminal that is created on the extension host side is temporarily assigned
+ * a UUID by the extension host that created it. Once the renderer side has assigned
+ * a real numeric id, the numeric id will be used.
+ *
+ * All other terminals (that are not created on the extension host side) always
+ * use the numeric id.
+ */
 export type ExtHostTerminalIdentifier = number | string;
 export interface TerminalLaunchConfig {
     name?: string;
@@ -853,6 +861,9 @@ export declare enum WebviewMessageArrayBufferViewType {
 export interface WebviewMessageArrayBufferReference {
     readonly $$vscode_array_buffer_reference$$: true;
     readonly index: number;
+    /**
+     * Tracks if the reference is to a view instead of directly to an ArrayBuffer.
+     */
     readonly view?: {
         readonly type: WebviewMessageArrayBufferViewType;
         readonly byteLength: number;
@@ -1522,7 +1533,7 @@ export interface MainThreadSCMShape extends IDisposable {
         number,
         string,
         string,
-        SCMGroupFeatures,
+        SCMGroupFeatures, /* multiDiffEditorEnableViewChanges */
         boolean
     ][], splices: SCMRawResourceSplices[]): Promise<void>;
     $updateGroup(sourceControlHandle: number, handle: number, features: SCMGroupFeatures): Promise<void>;
@@ -1630,9 +1641,19 @@ export interface MainThreadTimelineShape extends IDisposable {
     $emitTimelineChangeEvent(e: TimelineChangeEvent | undefined): void;
 }
 export interface HoverWithId extends languages.Hover {
+    /**
+     * Id of the hover
+     */
     id: number;
 }
 export interface ICommandMetadataDto {
+    /**
+     * NOTE: Please use an ILocalizedString. string is in the type for backcompat for now.
+     * A short summary of what the command does. This will be used in:
+     * - API commands
+     * - when showing keybindings that have no other UX
+     * - when searching for commands in the Command Palette
+     */
     readonly description: ILocalizedString | string;
     readonly args?: ReadonlyArray<{
         readonly name: string;
@@ -1744,7 +1765,7 @@ export interface DataTransferItemDTO {
     readonly uriListData?: ReadonlyArray<string | UriComponents>;
 }
 export interface DataTransferDTO {
-    items: Array<readonly [
+    items: Array<readonly [ /* type */
         string,
         DataTransferItemDTO
     ]>;
@@ -1754,6 +1775,16 @@ export interface CheckboxUpdate {
     newState: boolean;
 }
 export interface ExtHostTreeViewsShape {
+    /**
+     * To reduce what is sent on the wire:
+     * w
+     * 	x
+     *  y
+     *   z
+     *
+     * for [x,y] returns
+     * [[1,z]], where the inner array is [original index, ...children]
+     */
     $getChildren(treeViewId: string, treeItemHandles?: string[]): Promise<(number | ITreeItem)[][] | undefined>;
     $handleDrop(destinationViewId: string, requestId: number, treeDataTransfer: DataTransferDTO, targetHandle: string | undefined, token: CancellationToken, operationUuid?: string, sourceViewId?: string, sourceTreeItemHandles?: string[]): Promise<void>;
     $handleDrag(sourceViewId: string, sourceTreeItemHandles: string[], operationUuid: string, token: CancellationToken): Promise<DataTransferDTO | undefined>;
@@ -1851,6 +1882,9 @@ export interface ExtHostSearchShape {
 }
 export interface ExtHostExtensionServiceShape {
     $resolveAuthority(remoteAuthority: string, resolveAttempt: number): Promise<Dto<IResolveAuthorityResult>>;
+    /**
+     * Returns `null` if no resolver for `remoteAuthority` is found.
+     */
     $getCanonicalURI(remoteAuthority: string, uri: UriComponents): Promise<UriComponents | null>;
     $startExtensionHost(extensionsDelta: IExtensionDescriptionDelta): Promise<void>;
     $extensionTestsExecute(): Promise<number>;
@@ -2240,9 +2274,13 @@ export interface ExtHostTelemetryShape {
     $onDidChangeTelemetryLevel(level: TelemetryLevel): void;
 }
 export interface ITerminalLinkDto {
+    /** The ID of the link to enable activation and disposal. */
     id: number;
+    /** The startIndex of the link in the line. */
     startIndex: number;
+    /** The length of the link in the line. */
     length: number;
+    /** The descriptive label for what the link does when activated. */
     label?: string;
 }
 export interface ITerminalDimensionsDto {
@@ -2295,9 +2333,25 @@ export interface ITerminalCompletionProvider {
     triggerCharacters?: string[];
     isBuiltin?: boolean;
 }
+/**
+ * Represents a collection of {@link CompletionItem completion items} to be presented
+ * in the editor.
+ */
 export declare class TerminalCompletionListDto<T extends ITerminalCompletionItemDto = ITerminalCompletionItemDto> {
+    /**
+     * Resources should be shown in the completions list
+     */
     resourceRequestConfig?: TerminalResourceRequestConfigDto;
+    /**
+     * The completion items.
+     */
     items: T[];
+    /**
+     * Creates a new completion list.
+     *
+     * @param items The completion items.
+     * @param isIncomplete The list is not complete.
+     */
     constructor(items?: T[], resourceRequestConfig?: TerminalResourceRequestConfigDto);
 }
 export interface TerminalResourceRequestConfigDto {
@@ -2733,19 +2787,31 @@ export interface ExtHostTestingShape {
         error?: string;
     }[]>;
     $cancelExtensionTestRun(runId: string | undefined, taskId: string | undefined): void;
+    /** Handles a diff of tests, as a result of a subscribeToDiffs() call */
     $acceptDiff(diff: TestsDiffOp.Serialized[]): void;
+    /** Expands a test item's children, by the given number of levels. */
     $expandTest(testId: string, levels: number): Promise<void>;
+    /** Requests coverage details for a test run. Errors if not available. */
     $getCoverageDetails(coverageId: string, testId: string | undefined, token: CancellationToken): Promise<CoverageDetails.Serialized[]>;
+    /** Disposes resources associated with a test run. */
     $disposeRun(runId: string): void;
+    /** Configures a test run config. */
     $configureRunProfile(controllerId: string, configId: number): void;
+    /** Asks the controller to refresh its tests */
     $refreshTests(controllerId: string, token: CancellationToken): Promise<void>;
+    /** Ensures any pending test diffs are flushed */
     $syncTests(): Promise<void>;
-    $setDefaultRunProfiles(profiles: Record<string, number[]>): void;
+    /** Sets the active test run profiles */
+    $setDefaultRunProfiles(profiles: Record</* controller id */ string, /* profile id */ number[]>): void;
     $getTestsRelatedToCode(uri: UriComponents, position: IPosition, token: CancellationToken): Promise<string[]>;
     $getCodeRelatedToTest(testId: string, token: CancellationToken): Promise<ILocationDto[]>;
+    /** Publishes that a test run finished. */
     $publishTestResults(results: ISerializedTestResults[]): void;
+    /** Requests followup actions for a test (failure) message */
     $provideTestFollowups(req: TestMessageFollowupRequest, token: CancellationToken): Promise<TestMessageFollowupResponse[]>;
+    /** Actions a followup actions for a test (failure) message */
     $executeTestFollowup(id: number): Promise<void>;
+    /** Disposes followup actions for a test (failure) message */
     $disposeTestFollowups(id: number[]): void;
 }
 export interface ExtHostMcpShape {
@@ -2786,26 +2852,50 @@ export interface ITestControllerPatch {
     capabilities?: TestControllerCapability;
 }
 export interface MainThreadTestingShape {
+    /** Registers that there's a test controller with the given ID */
     $registerTestController(controllerId: string, label: string, capability: TestControllerCapability): void;
+    /** Updates the label of an existing test controller. */
     $updateController(controllerId: string, patch: ITestControllerPatch): void;
+    /** Diposes of the test controller with the given ID */
     $unregisterTestController(controllerId: string): void;
+    /** Requests tests published to VS Code. */
     $subscribeToDiffs(): void;
+    /** Stops requesting tests published to VS Code. */
     $unsubscribeFromDiffs(): void;
+    /** Publishes that new tests were available on the given source. */
     $publishDiff(controllerId: string, diff: TestsDiffOp.Serialized[]): void;
+    /** Gets coverage details from a test result. */
     $getCoverageDetails(resultId: string, taskIndex: number, uri: UriComponents, token: CancellationToken): Promise<CoverageDetails.Serialized[]>;
+    /** Called when a new test run configuration is available */
     $publishTestRunProfile(config: ITestRunProfile): void;
+    /** Updates an existing test run configuration */
     $updateTestRunConfig(controllerId: string, configId: number, update: Partial<ITestRunProfile>): void;
+    /** Removes a previously-published test run config */
     $removeTestProfile(controllerId: string, configId: number): void;
+    /** Request by an extension to run tests. */
     $runTests(req: ResolvedTestRunRequest, token: CancellationToken): Promise<string>;
+    /**
+     * Adds tests to the run. The tests are given in descending depth. The first
+     * item will be a previously-known test, or a test root.
+     */
     $addTestsToRun(controllerId: string, runId: string, tests: ITestItem.Serialized[]): void;
+    /** Updates the state of a test run in the given run. */
     $updateTestStateInRun(runId: string, taskId: string, testId: string, state: TestResultState, duration?: number): void;
+    /** Appends a message to a test in the run. */
     $appendTestMessagesInRun(runId: string, taskId: string, testId: string, messages: ITestMessage.Serialized[]): void;
+    /** Appends raw output to the test run.. */
     $appendOutputToRun(runId: string, taskId: string, output: VSBuffer, location?: ILocationDto, testId?: string): void;
+    /** Triggered when coverage is added to test results. */
     $appendCoverage(runId: string, taskId: string, coverage: IFileCoverage.Serialized): void;
+    /** Signals a task in a test run started. */
     $startedTestRunTask(runId: string, task: ITestRunTask): void;
+    /** Signals a task in a test run ended. */
     $finishedTestRunTask(runId: string, taskId: string): void;
+    /** Start a new extension-provided test run. */
     $startedExtensionTestRun(req: ExtensionRunTestsRequest): void;
+    /** Signals that an extension-provided test run finished. */
     $finishedExtensionTestRun(runId: string): void;
+    /** Marks a test (or controller) as retired in all results. */
     $markTestRetired(testIds: string[] | undefined): void;
 }
 export type ChatStatusItemDto = {

package/vscode/src/vs/workbench/api/common/extHostAuthentication.d.ts

@@ -31,6 +31,12 @@ export declare class ExtHostAuthentication implements ExtHostAuthenticationShape
     private _getSessionTaskSingler;
     private _onDidDynamicAuthProviderTokensChange;
     constructor(extHostRpc: IExtHostRpcService, _initData: IExtHostInitDataService, _extHostWindow: IExtHostWindow, _extHostUrls: IExtHostUrlsService, _extHostProgress: IExtHostProgress, _extHostLoggerService: ILoggerService, _logService: ILogService);
+    /**
+     * This sets up an event that will fire when the auth sessions change with a built-in filter for the extensionId
+     * if a session change only affects a specific extension.
+     * @param extensionId The extension that is interested in the event.
+     * @returns An event with a built-in filter for the extensionId
+     */
     getExtensionScopedSessionsEvent(extensionId: string): Event<vscode.AuthenticationSessionsChangeEvent>;
     getSession(requestingExtension: IExtensionDescription, providerId: string, scopes: readonly string[], options: vscode.AuthenticationGetSessionOptions & ({
         createIfNone: true;
@@ -102,6 +108,9 @@ export declare class DynamicAuthProvider implements vscode.AuthenticationProvide
     protected _generateNewClientId(): Promise<void>;
 }
 type IAuthorizationToken = IAuthorizationTokenResponse & {
+    /**
+     * The time when the token was created, in milliseconds since the epoch.
+     */
     created_at: number;
 };
 export {};

package/vscode/src/vs/workbench/api/common/extHostConsoleForwarder.d.ts

@@ -5,6 +5,15 @@ export declare abstract class AbstractExtHostConsoleForwarder {
     private readonly _includeStack;
     private readonly _logNative;
     constructor(extHostRpc: IExtHostRpcService, initData: IExtHostInitDataService);
+    /**
+     * Wraps a console message so that it is transmitted to the renderer. If
+     * native logging is turned on, the original console message will be written
+     * as well. This is needed since the console methods are "magic" in V8 and
+     * are the only methods that allow later introspection of logged variables.
+     *
+     * The wrapped property is not defined with `writable: false` to avoid
+     * throwing errors, but rather a no-op setting. See https://github.com/microsoft/vscode-extension-telemetry/issues/88
+     */
     private _wrapConsoleMethod;
     private _handleConsoleCall;
     protected abstract _nativeConsoleLogMessage(method: "log" | "info" | "warn" | "error" | "debug", original: (...args: any[]) => void, args: IArguments): void;

package/vscode/src/vs/workbench/api/common/extHostExtensionActivator.d.ts

@@ -4,10 +4,16 @@ import { ExtensionDescriptionRegistry } from "../../services/extensions/common/e
 import { ExtensionIdentifier } from "../../../platform/extensions/common/extensions.js";
 import { ExtensionActivationReason, MissingExtensionDependency } from "../../services/extensions/common/extensions.js";
 import { ILogService } from "../../../platform/log/common/log.service.js";
+/**
+ * Represents the source code (module) of an extension.
+ */
 export interface IExtensionModule {
     activate?(ctx: vscode.ExtensionContext): Promise<IExtensionAPI>;
     deactivate?(): void;
 }
+/**
+ * Represents the API of an extension (return value of `activate`).
+ */
 export interface IExtensionAPI {
 }
 export type ExtensionActivationTimesFragment = {
@@ -83,6 +89,9 @@ export declare class ExtensionsActivator implements IDisposable {
     private readonly _globalRegistry;
     private readonly _host;
     private readonly _operations;
+    /**
+     * A map of already activated events to speed things up if the same activation event is triggered multiple times.
+     */
     private readonly _alreadyActivatedEvents;
     constructor(registry: ExtensionDescriptionRegistry, globalRegistry: ExtensionDescriptionRegistry, host: IExtensionsActivatorHost, _logService: ILogService);
     dispose(): void;
@@ -92,6 +101,10 @@ export declare class ExtensionsActivator implements IDisposable {
     activateByEvent(activationEvent: string, startup: boolean): Promise<void>;
     activateById(extensionId: ExtensionIdentifier, reason: ExtensionActivationReason): Promise<void>;
     private _activateExtensions;
+    /**
+     * Handle semantics related to dependencies for `currentExtension`.
+     * We don't need to worry about dependency loops because they are handled by the registry.
+     */
     private _handleActivationRequest;
     private _createAndSaveOperation;
     private _isHostExtension;

package/vscode/src/vs/workbench/api/common/extHostExtensionService.d.ts

@@ -83,8 +83,15 @@ export declare abstract class AbstractExtHostExtensionService extends Disposable
     activateByIdWithErrors(extensionId: ExtensionIdentifier, reason: ExtensionActivationReason): Promise<void>;
     getExtensionRegistry(): Promise<ExtensionDescriptionRegistry>;
     getExtensionExports(extensionId: ExtensionIdentifier): IExtensionAPI | null | undefined;
+    /**
+     * Applies realpath to file-uris and returns all others uris unmodified.
+     * The real path is cached for the lifetime of the extension host.
+     */
     private _realPathExtensionUri;
     getExtensionPathIndex(): Promise<ExtensionPaths>;
+    /**
+     * create trie to enable fast 'filename -> extension id' look up
+     */
     private _createExtensionPathIndex;
     private _deactivate;
     private _activateExtension;

package/vscode/src/vs/workbench/api/common/extHostLanguageModelTools.d.ts

@@ -8,9 +8,11 @@ import { ExtHostLanguageModelToolsShape, IMainContext, IToolDataDto } from "./ex
 import { ExtHostLanguageModels } from "./extHostLanguageModels.js";
 export declare class ExtHostLanguageModelTools implements ExtHostLanguageModelToolsShape {
     private readonly _languageModels;
+    /** A map of tools that were registered in this EH */
     private readonly _registeredTools;
     private readonly _proxy;
     private readonly _tokenCountFuncs;
+    /** A map of all known tools, from other EHs or registered in vscode core */
     private readonly _allTools;
     constructor(mainContext: IMainContext, _languageModels: ExtHostLanguageModels);
     $countTokensForInvocation(callId: string, input: string, token: CancellationToken): Promise<number>;

package/vscode/src/vs/workbench/api/common/extHostMcp.d.ts

@@ -24,5 +24,6 @@ export declare class ExtHostMcpService extends Disposable implements IExtHostMpc
     $sendMessage(id: number, message: string): void;
     $waitForInitialCollectionProviders(): Promise<void>;
     $resolveMcpLaunch(collectionId: string, label: string): Promise<McpServerLaunch.Serialized | undefined>;
+    /** {@link vscode.lm.registerMcpServerDefinitionProvider} */
     registerMcpConfigurationProvider(extension: IExtensionDescription, id: string, provider: vscode.McpServerDefinitionProvider): IDisposable;
 }

package/vscode/src/vs/workbench/api/common/extHostNotebook.d.ts

@@ -68,6 +68,17 @@ export declare class ExtHostNotebookController implements ExtHostNotebookShape {
     $dataToNotebook(handle: number, bytes: VSBuffer, token: CancellationToken): Promise<SerializableObjectWithBuffers<NotebookDataDto>>;
     $notebookToData(handle: number, data: SerializableObjectWithBuffers<NotebookDataDto>, token: CancellationToken): Promise<VSBuffer>;
     $saveNotebook(handle: number, uriComponents: UriComponents, versionId: number, options: files.IWriteFileOptions, token: CancellationToken): Promise<INotebookPartialFileStatsWithMetadata>;
+    /**
+     * Search for query in all notebooks that can be deserialized by the serializer fetched by `handle`.
+     *
+     * @param handle used to get notebook serializer
+     * @param textQuery the text query to search using
+     * @param viewTypeFileTargets the globs (and associated ranks) that are targetting for opening this type of notebook
+     * @param otherViewTypeFileTargets ranked globs for other editors that we should consider when deciding whether it will open as this notebook
+     * @param token cancellation token
+     * @returns `IRawClosedNotebookFileMatch` for every file. Files without matches will just have a `IRawClosedNotebookFileMatch`
+     * 	with no `cellResults`. This allows the caller to know what was searched in already, even if it did not yield results.
+     */
     $searchInNotebooks(handle: number, textQuery: ITextQuery, viewTypeFileTargets: NotebookPriorityInfo[], otherViewTypeFileTargets: NotebookPriorityInfo[], token: CancellationToken): Promise<{
         results: IRawClosedNotebookFileMatch[];
         limitHit: boolean;

package/vscode/src/vs/workbench/api/common/extHostTerminalService.d.ts

@@ -45,6 +45,10 @@ export interface ITerminalInternalOptions {
     forceShellIntegration?: boolean;
     useShellEnvironment?: boolean;
     resolvedExtHostIdentifier?: ExtHostTerminalIdentifier;
+    /**
+     * This location is different from the API location because it can include splitActiveTerminal,
+     * a property we resolve internally
+     */
     location?: TerminalLocation | {
         viewColumn: number;
         preserveState?: boolean;
@@ -184,6 +188,9 @@ export declare abstract class BaseExtHostTerminalService extends Disposable impl
     $acceptDefaultProfile(profile: ITerminalProfile, automationProfile: ITerminalProfile): void;
     private _setEnvironmentVariableCollection;
 }
+/**
+ * Unified environment variable collection carrying information for all scopes, for a specific extension.
+ */
 declare class UnifiedEnvironmentVariableCollection extends Disposable {
     readonly map: Map<string, IEnvironmentVariableMutator>;
     private readonly scopedCollections;

package/vscode/src/vs/workbench/api/common/extHostTestItem.d.ts

@@ -16,6 +16,9 @@ export declare class TestItemImpl implements vscode.TestItem {
     busy: boolean;
     canResolveChildren: boolean;
     tags: readonly vscode.TestTag[];
+    /**
+     * Note that data is deprecated and here for back-compat only
+     */
     constructor(controllerId: string, id: string, label: string, uri: vscode.Uri | undefined);
 }
 export declare class TestItemRootImpl extends TestItemImpl {