@codingame/monaco-vscode-api 20.1.1 → 20.2.0

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

@@ -21,7 +21,7 @@ interface ControllerInfo {
     relatedCodeProvider?: vscode.TestRelatedCodeProvider;
     activeProfiles: Set<number>;
 }
-type DefaultProfileChangeEvent = Map<string, Map<number, boolean>>;
+type DefaultProfileChangeEvent = Map</* controllerId */ string, Map</* profileId */ number, boolean>>;
 export declare const IExtHostTesting: import("../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IExtHostTesting>;
 export interface IExtHostTesting extends ExtHostTesting {
     readonly _serviceBrand: undefined;
@@ -42,26 +42,82 @@ export declare class ExtHostTesting extends Disposable implements ExtHostTesting
     onResultsChanged: Event<void>;
     results: ReadonlyArray<vscode.TestRunResult>;
     constructor(rpc: IExtHostRpcService, logService: ILogService, commands: IExtHostCommands, editors: IExtHostDocumentsAndEditors);
+    /**
+     * Implements vscode.test.registerTestProvider
+     */
     createTestController(extension: IExtensionDescription, controllerId: string, label: string, refreshHandler?: (token: CancellationToken) => Thenable<void> | void): vscode.TestController;
+    /**
+     * Implements vscode.test.createTestObserver
+     */
     createTestObserver(): vscode.TestObserver;
+    /**
+     * Implements vscode.test.runTests
+     */
     runTests(req: vscode.TestRunRequest, token?: Readonly<CancellationToken>): Promise<void>;
+    /**
+     * Implements vscode.test.registerTestFollowupProvider
+     */
     registerTestFollowupProvider(provider: vscode.TestFollowupProvider): vscode.Disposable;
+    /**
+     * @inheritdoc
+     */
     $getTestsRelatedToCode(uri: UriComponents, _position: IPosition, token: CancellationToken): Promise<string[]>;
+    /**
+     * @inheritdoc
+     */
     $getCodeRelatedToTest(testId: string, token: CancellationToken): Promise<ILocationDto[]>;
+    /**
+     * @inheritdoc
+     */
     $syncTests(): Promise<void>;
+    /**
+     * @inheritdoc
+     */
     $getCoverageDetails(coverageId: string, testId: string | undefined, token: CancellationToken): Promise<CoverageDetails.Serialized[]>;
+    /**
+     * @inheritdoc
+     */
     $disposeRun(runId: string): Promise<void>;
+    /** @inheritdoc */
     $configureRunProfile(controllerId: string, profileId: number): void;
-    $setDefaultRunProfiles(profiles: Record<string, number[]>): void;
+    /** @inheritdoc */
+    $setDefaultRunProfiles(profiles: Record</* controller id */ string, /* profile id */ number[]>): void;
+    /** @inheritdoc */
     $refreshTests(controllerId: string, token: CancellationToken): Promise<void>;
+    /**
+     * Updates test results shown to extensions.
+     * @override
+     */
     $publishTestResults(results: ISerializedTestResults[]): void;
+    /**
+     * Expands the nodes in the test tree. If levels is less than zero, it will
+     * be treated as infinite.
+     */
     $expandTest(testId: string, levels: number): Promise<void>;
+    /**
+     * Receives a test update from the main thread. Called (eventually) whenever
+     * tests change.
+     */
     $acceptDiff(diff: TestsDiffOp.Serialized[]): void;
+    /**
+     * Runs tests with the given set of IDs. Allows for test from multiple
+     * providers to be run.
+     * @inheritdoc
+     */
     $runControllerTests(reqs: IStartControllerTests[], token: CancellationToken): Promise<IStartControllerTestsResult[]>;
+    /**
+     * Starts continuous test runs with the given set of IDs. Allows for test from
+     * multiple providers to be run.
+     * @inheritdoc
+     */
     $startContinuousRun(reqs: IStartControllerTests[], token: CancellationToken): Promise<IStartControllerTestsResult[]>;
+    /** @inheritdoc */
     $provideTestFollowups(req: TestMessageFollowupRequest, token: CancellationToken): Promise<TestMessageFollowupResponse[]>;
     $disposeTestFollowups(id: number[]): void;
     $executeTestFollowup(id: number): Promise<void>;
+    /**
+     * Cancels an ongoing test run.
+     */
     $cancelExtensionTestRun(runId: string | undefined, taskId: string | undefined): void;
     getMetadataForRun(run: vscode.TestRun): {
         taskId: string;
@@ -83,19 +139,36 @@ declare class TestRunTracker extends Disposable {
     private readonly endEmitter;
     private readonly onDidDispose;
     private readonly publishedCoverage;
+    /**
+     * Fires when a test ends, and no more tests are left running.
+     */
     readonly onEnd: Event<void>;
+    /**
+     * Gets whether there are any tests running.
+     */
     get hasRunningTasks(): boolean;
+    /**
+     * Gets the run ID.
+     */
     get id(): string;
     constructor(dto: TestRunDto, proxy: MainThreadTestingShape, logService: ILogService, profile: vscode.TestRunProfile | undefined, extension: IExtensionDescription, parentToken?: CancellationToken);
+    /** Gets the task ID from a test run object. */
     getTaskIdForRun(run: vscode.TestRun): string | undefined;
+    /** Requests cancellation of the run. On the second call, forces cancellation. */
     cancel(taskId?: string): void;
+    /** Gets details for a previously-emitted coverage object. */
     getCoverageDetails(id: string, testId: string | undefined, token: CancellationToken): Promise<vscode.FileCoverageDetail[]>;
+    /** Creates the public test run interface to give to extensions. */
     createRun(name: string | undefined): vscode.TestRun;
     private forciblyEndTasks;
     private markEnded;
     private ensureTestIsKnown;
     dispose(): void;
 }
+/**
+ * Queues runs for a single extension and provides the currently-executing
+ * run so that `createTestRun` can be properly correlated.
+ */
 export declare class TestRunCoordinator {
     private readonly proxy;
     private readonly logService;
@@ -103,11 +176,32 @@ export declare class TestRunCoordinator {
     private readonly trackedById;
     get trackers(): MapIterator<TestRunTracker>;
     constructor(proxy: MainThreadTestingShape, logService: ILogService);
+    /**
+     * Gets a coverage report for a given run and task ID.
+     */
     getCoverageDetails(id: string, testId: string | undefined, token: vscode.CancellationToken): never[] | Promise<vscode.FileCoverageDetail[]>;
+    /**
+     * Disposes the test run, called when the main thread is no longer interested
+     * in associated data.
+     */
     disposeTestRun(runId: string): void;
+    /**
+     * Registers a request as being invoked by the main thread, so
+     * `$startedExtensionTestRun` is not invoked. The run must eventually
+     * be cancelled manually.
+     */
     prepareForMainThreadTestRun(extension: IExtensionDescription, req: vscode.TestRunRequest, dto: TestRunDto, profile: vscode.TestRunProfile, token: CancellationToken): TestRunTracker;
+    /**
+     * Cancels an existing test run via its cancellation token.
+     */
     cancelRunById(runId: string, taskId?: string): void;
+    /**
+     * Cancels an existing test run via its cancellation token.
+     */
     cancelAllRuns(): void;
+    /**
+     * Implements the public `createTestRun` API.
+     */
     createTestRun(extension: IExtensionDescription, controllerId: string, collection: ExtHostTestItemCollection, request: vscode.TestRunRequest, name: string | undefined, persist: boolean): vscode.TestRun;
     private getTracker;
 }

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

@@ -6,4 +6,9 @@ export interface IExtHostTestItemApi {
     listener?: (evt: ExtHostTestItemEvent) => void;
 }
 export declare const createPrivateApiFor: (impl: vscode.TestItem, controllerId: string) => IExtHostTestItemApi;
+/**
+ * Gets the private API for a test item implementation. This implementation
+ * is a managed object, but we keep a weakmap to avoid exposing any of the
+ * internals to extensions.
+ */
 export declare const getPrivateApiFor: (impl: vscode.TestItem) => IExtHostTestItemApi;

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

@@ -47,6 +47,14 @@ export declare class ExtHostTunnelService extends Disposable implements IExtHost
     $providePortAttributes(handles: number[], ports: number[], pid: number | undefined, commandLine: string | undefined, cancellationToken: vscode.CancellationToken): Promise<ProvidedPortAttributes[]>;
     $registerCandidateFinder(_enable: boolean): Promise<void>;
     registerTunnelProvider(provider: vscode.TunnelProvider, information: vscode.TunnelInformation): Promise<IDisposable>;
+    /**
+     * Applies the tunnel metadata and factory found in the remote authority
+     * resolver to the tunnel system.
+     *
+     * `managedRemoteAuthority` should be be passed if the resolver returned on.
+     * If this is the case, the tunnel cannot be connected to via a websocket from
+     * the share process, so a synethic tunnel factory is used as a default.
+     */
     setTunnelFactory(provider: vscode.RemoteAuthorityResolver | undefined, managedRemoteAuthority: vscode.ManagedResolvedAuthority | undefined): Promise<IDisposable>;
     protected makeManagedTunnelFactory(_authority: vscode.ManagedResolvedAuthority): vscode.RemoteAuthorityResolver["tunnelFactory"];
     $closeTunnel(remote: {

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

@@ -688,10 +688,25 @@ export declare enum TextDocumentChangeReason {
     Undo = 1,
     Redo = 2
 }
+/**
+ * These values match very carefully the values of `TrackedRangeStickiness`
+ */
 export declare enum DecorationRangeBehavior {
+    /**
+     * TrackedRangeStickiness.AlwaysGrowsWhenTypingAtEdges
+     */
     OpenOpen = 0,
+    /**
+     * TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges
+     */
     ClosedClosed = 1,
+    /**
+     * TrackedRangeStickiness.GrowsOnlyWhenTypingBefore
+     */
     OpenClosed = 2,
+    /**
+     * TrackedRangeStickiness.GrowsOnlyWhenTypingAfter
+     */
     ClosedOpen = 3
 }
 export declare namespace TextEditorSelectionChangeKind {
@@ -817,9 +832,25 @@ export declare class TerminalCompletionItem implements vscode.TerminalCompletion
     replacementLength: number;
     constructor(label: string | CompletionItemLabel, icon?: ThemeIcon, detail?: string, documentation?: string | vscode.MarkdownString, isFile?: boolean, isDirectory?: boolean, isKeyword?: boolean, replacementIndex?: number, replacementLength?: number);
 }
+/**
+ * Represents a collection of {@link CompletionItem completion items} to be presented
+ * in the editor.
+ */
 export declare class TerminalCompletionList<T extends TerminalCompletionItem = TerminalCompletionItem> {
+    /**
+     * Resources should be shown in the completions list
+     */
     resourceRequestConfig?: TerminalResourceRequestConfig;
+    /**
+     * 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?: TerminalResourceRequestConfig);
 }
 export interface TerminalResourceRequestConfig {
@@ -834,18 +865,31 @@ export declare enum TaskRevealKind {
     Never = 3
 }
 export declare enum TaskEventKind {
+    /** Indicates a task's properties or configuration have changed */
     Changed = "changed",
+    /** Indicates a task has begun executing */
     ProcessStarted = "processStarted",
+    /** Indicates a task process has completed */
     ProcessEnded = "processEnded",
+    /** Indicates a task was terminated, either by user action or by the system */
     Terminated = "terminated",
+    /** Indicates a task has started running */
     Start = "start",
+    /** Indicates a task has acquired all needed input/variables to execute */
     AcquiredInput = "acquiredInput",
+    /** Indicates a dependent task has started */
     DependsOnStarted = "dependsOnStarted",
+    /** Indicates a task is actively running/processing */
     Active = "active",
+    /** Indicates a task is paused/waiting but not complete */
     Inactive = "inactive",
+    /** Indicates a task has completed fully */
     End = "end",
+    /** Indicates the task's problem matcher has started */
     ProblemMatcherStarted = "problemMatcherStarted",
+    /** Indicates the task's problem matcher has ended without errors */
     ProblemMatcherEnded = "problemMatcherEnded",
+    /** Indicates the task's problem matcher has ended with errors */
     ProblemMatcherFoundErrors = "problemMatcherFoundErrors"
 }
 export declare enum TaskPanelKind {
@@ -1001,13 +1045,26 @@ export declare class DataTransferItem implements vscode.DataTransferItem {
     asFile(): undefined | vscode.DataTransferFile;
     constructor(value: any);
 }
+/**
+ * A data transfer item that has been created by VS Code instead of by a extension.
+ *
+ * Intentionally not exported to extensions.
+ */
 export declare class InternalDataTransferItem extends DataTransferItem {
 }
+/**
+ * A data transfer item for a file.
+ *
+ * Intentionally not exported to extensions as only we can create these.
+ */
 export declare class InternalFileDataTransferItem extends InternalDataTransferItem {
     #private;
     constructor(file: vscode.DataTransferFile);
     asFile(): vscode.DataTransferFile;
 }
+/**
+ * Intentionally not exported to extensions
+ */
 export declare class DataTransferFile implements vscode.DataTransferFile {
     readonly name: string;
     readonly uri: vscode.Uri | undefined;
@@ -1088,6 +1145,14 @@ export declare class RelativePattern implements IRelativePattern {
     constructor(base: vscode.WorkspaceFolder | URI | string, pattern: string);
     toJSON(): IRelativePatternDto;
 }
+/**
+ * We want to be able to construct Breakpoints internally that have a particular id, but we don't want extensions to be
+ * able to do this with the exposed Breakpoint classes in extension API.
+ * We also want "instanceof" to work with debug.breakpoints and the exposed breakpoint classes.
+ * And private members will be renamed in the built js, so casting to any and setting a private member is not safe.
+ * So, we store internal breakpoint IDs in a WeakMap. This function must be called after constructing a Breakpoint
+ * with a known id.
+ */
 export declare function setBreakpointId(bp: Breakpoint, id: string): void;
 export declare class Breakpoint {
     private _id;
@@ -1219,7 +1284,13 @@ export declare enum FoldingRangeKind {
     Region = 3
 }
 export declare enum CommentThreadCollapsibleState {
+    /**
+     * Determines an item is collapsed
+     */
     Collapsed = 0,
+    /**
+     * Determines an item is expanded
+     */
     Expanded = 1
 }
 export declare enum CommentMode {
@@ -1281,7 +1352,14 @@ export declare class SemanticTokensEdits {
     constructor(edits: SemanticTokensEdit[], resultId?: string);
 }
 export declare enum DebugConsoleMode {
+    /**
+     * Debug session should have a separate debug console.
+     */
     Separate = 0,
+    /**
+     * Debug session should share debug console with its parent session.
+     * This value has no effect for sessions which do not have a parent session.
+     */
     MergeWithParent = 1
 }
 export declare class DebugVisualization {
@@ -1394,6 +1472,11 @@ export declare class CellErrorStackFrame {
     label: string;
     uri?: vscode.Uri | undefined;
     position?: Position | undefined;
+    /**
+     * @param label The name of the stack frame
+     * @param file The file URI of the stack frame
+     * @param position The position of the stack frame within the file
+     */
     constructor(label: string, uri?: vscode.Uri | undefined, position?: Position | undefined);
 }
 export declare enum NotebookCellKind {
@@ -1451,12 +1534,30 @@ export declare class TimelineItem implements vscode.TimelineItem {
     constructor(label: string, timestamp: number);
 }
 export declare enum ExtensionMode {
+    /**
+     * The extension is installed normally (for example, from the marketplace
+     * or VSIX) in VS Code.
+     */
     Production = 1,
+    /**
+     * The extension is running from an `--extensionDevelopmentPath` provided
+     * when launching VS Code.
+     */
     Development = 2,
+    /**
+     * The extension is running from an `--extensionDevelopmentPath` and
+     * the extension host is running unit tests.
+     */
     Test = 3
 }
 export declare enum ExtensionRuntime {
+    /**
+     * The extension is running in a NodeJS extension host. Runtime access to NodeJS APIs is available.
+     */
     Node = 1,
+    /**
+     * The extension is running in a Webworker extension host. Runtime access is limited to Webworker APIs.
+     */
     Webworker = 2
 }
 export declare enum StandardTokenType {
@@ -1508,6 +1609,7 @@ export declare class TestMessage implements vscode.TestMessage {
     actualOutput?: string;
     location?: vscode.Location;
     contextValue?: string;
+    /** proposed: */
     stackTrace?: TestMessageStackFrame[];
     static diff(message: string | vscode.MarkdownString, expected: string, actual: string): TestMessage;
     constructor(message: string | vscode.MarkdownString);
@@ -1520,6 +1622,11 @@ export declare class TestMessageStackFrame {
     label: string;
     uri?: vscode.Uri | undefined;
     position?: Position | undefined;
+    /**
+     * @param label The name of the stack frame
+     * @param file The file URI of the stack frame
+     * @param position The position of the stack frame within the file
+     */
     constructor(label: string, uri?: vscode.Uri | undefined, position?: Position | undefined);
 }
 export declare class TestCoverageCount implements vscode.TestCoverageCount {
@@ -1694,6 +1801,10 @@ export declare class ChatResponseMarkdownPart {
     value: vscode.MarkdownString;
     constructor(value: string | vscode.MarkdownString);
 }
+/**
+ * TODO if 'vulnerabilities' is finalized, this should be merged with the base ChatResponseMarkdownPart. I just don't see how to do that while keeping
+ * vulnerabilities in a seperate API proposal in a clean way.
+ */
 export declare class ChatResponseMarkdownWithVulnerabilitiesPart {
     value: vscode.MarkdownString;
     vulnerabilities: vscode.ChatVulnerability[];
@@ -1817,6 +1928,9 @@ export declare class ChatResponseNotebookEditPart implements vscode.ChatResponse
 }
 export declare class ChatPrepareToolInvocationPart {
     toolName: string;
+    /**
+     * @param toolName The name of the tool being prepared for invocation.
+     */
     constructor(toolName: string);
 }
 export interface ChatTerminalToolInvocationData2 {
@@ -1998,15 +2112,24 @@ export declare class LanguageModelPromptTsxPart {
         value: unknown;
     };
 }
+/**
+ * @deprecated
+ */
 export declare class LanguageModelChatSystemMessage {
     content: string;
     constructor(content: string);
 }
+/**
+ * @deprecated
+ */
 export declare class LanguageModelChatUserMessage {
     content: string;
     name: string | undefined;
     constructor(content: string, name?: string);
 }
+/**
+ * @deprecated
+ */
 export declare class LanguageModelChatAssistantMessage {
     content: string;
     name?: string;

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

@@ -65,6 +65,9 @@ export declare class ExtHostWorkspace implements ExtHostWorkspaceShape, IExtHost
     getRelativePath(pathOrUri: string | vscode.Uri, includeWorkspace?: boolean): string;
     private trySetWorkspaceFolders;
     $acceptWorkspaceData(data: IWorkspaceData | null): void;
+    /**
+     * Note, null/undefined have different and important meanings for "exclude"
+     */
     findFiles(include: vscode.GlobPattern | undefined, exclude: vscode.GlobPattern | null | undefined, maxResults: number | undefined, extensionId: ExtensionIdentifier, token?: vscode.CancellationToken): Promise<vscode.Uri[]>;
     findFiles2(filePatterns: readonly vscode.GlobPattern[], options: vscode.FindFiles2Options | undefined, extensionId: ExtensionIdentifier, token?: vscode.CancellationToken): Promise<vscode.Uri[]>;
     private _findFilesImpl;

package/vscode/src/vs/workbench/browser/actions/media/actions.css

@@ -1,7 +1,14 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
 .monaco-workbench .quick-input-list .quick-input-list-entry.has-actions:hover .quick-input-list-entry-action-bar .action-label.dirty-workspace::before {
+	/* Close icon flips between black dot and "X" for dirty workspaces */
 	content: var(--vscode-icon-x-content);
 	font-family: var(--vscode-icon-x-font-family);
 }
+
 .monaco-workbench .screencast-mouse {
 	position: absolute;
 	border-width: 2px;
@@ -12,6 +19,7 @@
 	pointer-events: none;
 	display: none;
 }
+
 .monaco-workbench .screencast-keyboard {
 	position: absolute;
 	background-color: rgba(0, 0, 0 ,0.5);
@@ -26,12 +34,15 @@
 	overflow: hidden;
 	text-overflow: ellipsis;
 }
+
 .monaco-workbench:not(.reduce-motion) .screencast-keyboard {
 	transition: opacity 0.3s ease-out;
 }
+
 .monaco-workbench .screencast-keyboard:empty {
 	opacity: 0;
 }
+
 .monaco-workbench .screencast-keyboard > .key {
 	padding: 0 8px;
 	box-shadow: inset 0 -3px 0 hsla(0,0%,73%,.4);
@@ -40,6 +51,7 @@
 	border-radius: 5px;
 	background-color: rgba(255, 255, 255, 0.05);
 }
+
 .monaco-workbench .screencast-keyboard > .title {
 	font-weight: 600;
 }

package/vscode/src/vs/workbench/browser/parts/editor/editor.d.ts

@@ -20,6 +20,9 @@ export declare const DEFAULT_EDITOR_MAX_DIMENSIONS: Dimension;
 export declare const DEFAULT_EDITOR_PART_OPTIONS: IEditorPartOptions;
 export declare function impactsEditorPartOptions(event: IConfigurationChangeEvent): boolean;
 export declare function getEditorPartOptions(configurationService: IConfigurationService, themeService: IThemeService): IEditorPartOptions;
+/**
+ * A helper to access editor groups across all opened editor parts.
+ */
 export interface IEditorPartsView {
     readonly mainPart: IEditorGroupsView;
     registerPart(part: IEditorPart): IDisposable;
@@ -31,6 +34,9 @@ export interface IEditorPartsView {
     createAuxiliaryEditorPart(options?: IAuxiliaryWindowOpenOptions): Promise<IAuxiliaryEditorPart>;
     bind<T extends ContextKeyValue>(contextKey: RawContextKey<T>, group: IEditorGroupView): IContextKey<T>;
 }
+/**
+ * A helper to access and mutate editor groups within an editor part.
+ */
 export interface IEditorGroupsView {
     readonly windowId: number;
     readonly groups: IEditorGroupView[];
@@ -52,18 +58,40 @@ export interface IEditorGroupsView {
     toggleExpandGroup(group?: IEditorGroupView | GroupIdentifier): void;
 }
 export interface IEditorGroupTitleHeight {
+    /**
+     * The overall height of the editor group title control.
+     */
     readonly total: number;
+    /**
+     * The height offset to e.g. use when drawing drop overlays.
+     * This number may be smaller than `height` if the title control
+     * decides to have an `offset` that is within the title control
+     * (e.g. when breadcrumbs are enabled).
+     */
     readonly offset: number;
 }
 export interface IEditorGroupViewOptions {
+    /**
+     * Whether the editor group should receive keyboard focus
+     * after creation or not.
+     */
     readonly preserveFocus?: boolean;
 }
+/**
+ * A helper to access and mutate an editor group within an editor part.
+ */
 export interface IEditorGroupView extends IDisposable, ISerializableView, IEditorGroup {
     readonly onDidFocus: Event<void>;
     readonly onWillOpenEditor: Event<IEditorWillOpenEvent>;
     readonly onDidOpenEditorFail: Event<EditorInput>;
     readonly onDidCloseEditor: Event<IEditorCloseEvent>;
     readonly groupsView: IEditorGroupsView;
+    /**
+     * A promise that resolves when the group has been restored.
+     *
+     * For a group with active editor, the promise will resolve
+     * when the active editor has finished to resolve.
+     */
     readonly whenRestored: Promise<void>;
     readonly titleHeight: IEditorGroupTitleHeight;
     readonly disposed: boolean;
@@ -75,23 +103,64 @@ export interface IEditorGroupView extends IDisposable, ISerializableView, IEdito
 }
 export declare function fillActiveEditorViewState(group: IEditorGroup, expectedActiveEditor?: EditorInput, presetOptions?: IEditorOptions): IEditorOptions;
 export declare function prepareMoveCopyEditors(sourceGroup: IEditorGroup, editors: EditorInput[], preserveFocus?: boolean): EditorInputWithOptions[];
+/**
+ * A sub-interface of IEditorService to hide some workbench-core specific
+ * events from clients.
+ */
 export interface EditorServiceImpl extends IEditorService {
+    /**
+     * Emitted when an editor failed to open.
+     */
     readonly onDidOpenEditorFail: Event<IEditorIdentifier>;
+    /**
+     * Emitted when the list of most recently active editors change.
+     */
     readonly onDidMostRecentlyActiveEditorsChange: Event<void>;
 }
 export interface IInternalEditorTitleControlOptions {
+    /**
+     * A hint to defer updating the title control for perf reasons.
+     * The caller must ensure to update the title control then.
+     */
     readonly skipTitleUpdate?: boolean;
 }
 export interface IInternalEditorOpenOptions extends IInternalEditorTitleControlOptions {
+    /**
+     * Whether to consider a side by side editor as matching
+     * when figuring out if the editor to open is already
+     * opened or not. By default, side by side editors will
+     * not be considered as matching, even if the editor is
+     * opened in one of the sides.
+     */
     readonly supportSideBySide?: SideBySideEditor.ANY | SideBySideEditor.BOTH;
+    /**
+     * When set to `true`, pass DOM focus into the tab control.
+     */
     readonly focusTabControl?: boolean;
+    /**
+     * When set to `true`, will not attempt to move the window to
+     * the top that the editor opens in.
+     */
     readonly preserveWindowOrder?: boolean;
+    /**
+     * Inactive editors to select after opening the active selected editor.
+     */
     readonly inactiveSelection?: EditorInput[];
 }
 export interface IInternalEditorCloseOptions extends IInternalEditorTitleControlOptions {
+    /**
+     * A hint that the editor is closed due to an error opening. This can be
+     * used to optimize how error toasts are appearing if any.
+     */
     readonly fromError?: boolean;
+    /**
+     * Additional context as to why an editor is closed.
+     */
     readonly context?: EditorCloseContext;
 }
 export interface IInternalMoveCopyOptions extends IInternalEditorOpenOptions {
+    /**
+     * Whether to close the editor at the source or keep it.
+     */
     readonly keepCopy?: boolean;
 }

package/vscode/src/vs/workbench/common/composite.d.ts

@@ -1,12 +1,36 @@
 import { Event } from "../../base/common/event.js";
 export interface IComposite {
+    /**
+     * An event when the composite gained focus.
+     */
     readonly onDidFocus: Event<void>;
+    /**
+     * An event when the composite lost focus.
+     */
     readonly onDidBlur: Event<void>;
+    /**
+     * Returns true if the composite has focus.
+     */
     hasFocus(): boolean;
+    /**
+     * Returns the unique identifier of this composite.
+     */
     getId(): string;
+    /**
+     * Returns the name of this composite to show in the title area.
+     */
     getTitle(): string | undefined;
+    /**
+     * Returns the underlying control of this composite.
+     */
     getControl(): ICompositeControl | undefined;
+    /**
+     * Asks the underlying control to focus.
+     */
     focus(): void;
 }
+/**
+ * Marker interface for the composite control
+ */
 export interface ICompositeControl {
 }