@codingame/monaco-vscode-api 20.1.1 → 20.2.1

package/vscode/src/vs/workbench/contrib/terminal/browser/terminal.service.d.ts

@@ -13,12 +13,15 @@ import { IXtermCore } from "./xterm-private.js";
 export declare const ITerminalService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<ITerminalService>;
 export interface ITerminalService extends ITerminalInstanceHost {
     readonly _serviceBrand: undefined;
+    /** Gets all terminal instances, including editor and terminal view (group) instances. */
     readonly instances: readonly ITerminalInstance[];
+    /** Gets detached terminal instances created via {@link createDetachedXterm}. */
     readonly detachedInstances: Iterable<IDetachedTerminalInstance>;
     readonly defaultLocation: TerminalLocation;
     readonly isProcessSupportRegistered: boolean;
     readonly connectionState: TerminalConnectionState;
     readonly whenConnected: Promise<void>;
+    /** The number of restored terminal groups on startup. */
     readonly restoredGroupCount: number;
     readonly onDidCreateInstance: Event<ITerminalInstance>;
     readonly onDidChangeInstanceDimensions: Event<ITerminalInstance>;
@@ -42,10 +45,27 @@ export interface ITerminalService extends ITerminalInstanceHost {
     readonly onAnyInstanceTitleChange: Event<ITerminalInstance>;
     readonly onAnyInstanceShellTypeChanged: Event<ITerminalInstance>;
     readonly onAnyInstanceAddedCapabilityType: Event<TerminalCapability>;
+    /**
+    * Creates a terminal.
+    * @param options The options to create the terminal with, when not specified the default
+    * profile will be used at the default target.
+    */
     createTerminal(options?: ICreateTerminalOptions): Promise<ITerminalInstance>;
+    /**
+    * Creates a detached xterm instance which is not attached to the DOM or
+    * tracked as a terminal instance.
+    * @params options The options to create the terminal with
+    */
     createDetachedTerminal(options: IDetachedXTermOptions): Promise<IDetachedTerminalInstance>;
+    /**
+    * Creates a raw terminal instance, this should not be used outside of the terminal part.
+    */
     getInstanceFromId(terminalId: number): ITerminalInstance | undefined;
     getInstanceFromIndex(terminalIndex: number): ITerminalInstance;
+    /**
+    * An owner of terminals might be created after reconnection has occurred,
+    * so store them to be requested/adopted later
+    */
     getReconnectedTerminals(reconnectionOwner: string): ITerminalInstance[] | undefined;
     getActiveOrCreateInstance(options?: {
         acceptsInput?: boolean;
@@ -56,6 +76,10 @@ export interface ITerminalService extends ITerminalInstanceHost {
     moveIntoNewEditor(source: ITerminalInstance): void;
     moveToTerminalView(source: ITerminalInstance | URI): Promise<void>;
     getPrimaryBackend(): ITerminalBackend | undefined;
+    /**
+    * Fire the onActiveTabChanged event, this will trigger the terminal dropdown to be updated,
+    * among other things.
+    */
     refreshActiveGroup(): void;
     registerProcessSupport(isSupported: boolean): void;
     showProfileQuickPick(type: "setDefault" | "createInstance", cwd?: string | URI): Promise<ITerminalInstance | undefined>;
@@ -72,24 +96,49 @@ export interface ITerminalService extends ITerminalInstanceHost {
     setNativeDelegate(nativeCalls: ITerminalServiceNativeDelegate): void;
     getEditingTerminal(): ITerminalInstance | undefined;
     setEditingTerminal(instance: ITerminalInstance | undefined): void;
+    /**
+    * Creates an instance event listener that listens to all instances, dynamically adding new
+    * instances and removing old instances as needed.
+    * @param getEvent Maps the instance to the event.
+    */
     createOnInstanceEvent<T>(getEvent: (instance: ITerminalInstance) => Event<T>): DynamicListEventMultiplexer<ITerminalInstance, T>;
+    /**
+    * Creates a capability event listener that listens to capabilities on all instances,
+    * dynamically adding and removing instances and capabilities as needed.
+    * @param capabilityId The capability type to listen to an event on.
+    * @param getEvent Maps the capability to the event.
+    */
     createOnInstanceCapabilityEvent<T extends TerminalCapability, K>(capabilityId: T, getEvent: (capability: ITerminalCapabilityImplMap[T]) => Event<K>): IDynamicListEventMultiplexer<{
         instance: ITerminalInstance;
         data: K;
     }>;
 }
 export declare const ITerminalConfigurationService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<ITerminalConfigurationService>;
+/**
+* A service that provides convenient access to the terminal configuration and derived values.
+*/
 export interface ITerminalConfigurationService {
     readonly _serviceBrand: undefined;
+    /**
+    * A typed and partially validated representation of the terminal configuration.
+    */
     readonly config: Readonly<ITerminalConfiguration>;
+    /**
+    * Fires when something within the terminal configuration changes.
+    */
     readonly onConfigChanged: Event<void>;
     setPanelContainer(panelContainer: HTMLElement): void;
     configFontIsMonospace(): boolean;
     getFont(w: Window, xtermCore?: IXtermCore, excludeDimensions?: boolean): ITerminalFont;
 }
 export declare const ITerminalEditorService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<ITerminalEditorService>;
+/**
+* This service is responsible for integrating with the editor service and managing terminal
+* editors.
+*/
 export interface ITerminalEditorService extends ITerminalInstanceHost {
     readonly _serviceBrand: undefined;
+    /** Gets all _terminal editor_ instances. */
     readonly instances: readonly ITerminalInstance[];
     openEditor(instance: ITerminalInstance, editorOptions?: TerminalEditorLocation): Promise<void>;
     detachInstance(instance: ITerminalInstance): void;
@@ -100,21 +149,36 @@ export interface ITerminalEditorService extends ITerminalInstanceHost {
     getInputFromResource(resource: URI): EditorInput;
 }
 export declare const ITerminalGroupService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<ITerminalGroupService>;
+/**
+* This service is responsible for managing terminal groups, that is the terminals that are hosted
+* within the terminal panel, not in an editor.
+*/
 export interface ITerminalGroupService extends ITerminalInstanceHost {
     readonly _serviceBrand: undefined;
+    /** Gets all _terminal view_ instances, ie. instances contained within terminal groups. */
     readonly instances: readonly ITerminalInstance[];
     readonly groups: readonly ITerminalGroup[];
     activeGroup: ITerminalGroup | undefined;
     readonly activeGroupIndex: number;
+    /**
+    * Gets or sets the last accessed menu, this is used to select the instance(s) for menu actions.
+    */
     lastAccessedMenu: "inline-tab" | "tab-list";
     readonly onDidChangeActiveGroup: Event<ITerminalGroup | undefined>;
     readonly onDidDisposeGroup: Event<ITerminalGroup>;
+    /** Fires when a group is created, disposed of, or shown (in the case of a background group). */
     readonly onDidChangeGroups: Event<void>;
+    /** Fires when the panel has been shown and expanded, so has non-zero dimensions. */
     readonly onDidShow: Event<void>;
     readonly onDidChangePanelOrientation: Event<Orientation>;
     createGroup(shellLaunchConfig?: IShellLaunchConfig): ITerminalGroup;
     createGroup(instance?: ITerminalInstance): ITerminalGroup;
     getGroupForInstance(instance: ITerminalInstance): ITerminalGroup | undefined;
+    /**
+    * Moves a terminal instance's group to the target instance group's position.
+    * @param source The source instance to move.
+    * @param target The target instance to move the source instance to.
+    */
     moveGroup(source: ITerminalInstance | ITerminalInstance[], target: ITerminalInstance): void;
     moveGroupToEnd(source: ITerminalInstance | ITerminalInstance[]): void;
     moveInstance(source: ITerminalInstance, target: ITerminalInstance, side: "before" | "after"): void;
@@ -134,12 +198,40 @@ export interface ITerminalGroupService extends ITerminalInstanceHost {
     updateVisibility(): void;
 }
 export declare const ITerminalInstanceService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<ITerminalInstanceService>;
+/**
+* A service used to create instances or fetch backends, this services allows services that
+* ITerminalService depends on to also create instances.
+*
+* **This service is intended to only be used within the terminal contrib.**
+*/
 export interface ITerminalInstanceService {
     readonly _serviceBrand: undefined;
+    /**
+    * An event that's fired when a terminal instance is created.
+    */
     onDidCreateInstance: Event<ITerminalInstance>;
+    /**
+    * An event that's fired when a new backend is registered.
+    */
     onDidRegisterBackend: Event<ITerminalBackend>;
+    /**
+    * Helper function to convert a shell launch config, a profile or undefined into its equivalent
+    * shell launch config.
+    * @param shellLaunchConfigOrProfile A shell launch config, a profile or undefined
+    * @param cwd A cwd to override.
+    */
     convertProfileToShellLaunchConfig(shellLaunchConfigOrProfile?: IShellLaunchConfig | ITerminalProfile, cwd?: string | URI): IShellLaunchConfig;
+    /**
+    * Create a new terminal instance.
+    * @param launchConfig The shell launch config.
+    * @param target The target of the terminal.
+    */
     createInstance(launchConfig: IShellLaunchConfig, target: TerminalLocation): ITerminalInstance;
+    /**
+    * Gets the registered backend for a remote authority (undefined = local). This is a convenience
+    * method to avoid using the more verbose fetching from the registry.
+    * @param remoteAuthority The remote authority of the backend.
+    */
     getBackend(remoteAuthority?: string): Promise<ITerminalBackend | undefined>;
     getRegisteredBackends(): IterableIterator<ITerminalBackend>;
     didRegisterBackend(backend: ITerminalBackend): void;

package/vscode/src/vs/workbench/contrib/terminal/browser/xterm-private.d.ts

@@ -1,3 +1,7 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
 import { IBufferCell } from "@xterm/xterm";
 export type XtermAttributes = Omit<IBufferCell, "getWidth" | "getChars" | "getCode"> & {
     clone?(): XtermAttributes;

package/vscode/src/vs/workbench/contrib/terminal/common/environmentVariable.service.d.ts

@@ -1,11 +1,32 @@
 import { Event } from "../../../../base/common/event.js";
 import { IEnvironmentVariableCollection, IMergedEnvironmentVariableCollection } from "@codingame/monaco-vscode-07eaa805-9dea-5ec6-a422-a4f04872424d-common/vscode/vs/platform/terminal/common/environmentVariable";
 export declare const IEnvironmentVariableService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IEnvironmentVariableService>;
+/**
+* Tracks and persists environment variable collections as defined by extensions.
+*/
 export interface IEnvironmentVariableService {
     readonly _serviceBrand: undefined;
+    /**
+    * Gets a single collection constructed by merging all environment variable collections into
+    * one.
+    */
     readonly collections: ReadonlyMap<string, IEnvironmentVariableCollection>;
+    /**
+    * Gets a single collection constructed by merging all environment variable collections into
+    * one.
+    */
     readonly mergedCollection: IMergedEnvironmentVariableCollection;
+    /**
+    * An event that is fired when an extension's environment variable collection changes, the event
+    * provides the new merged collection.
+    */
     onDidChangeCollections: Event<IMergedEnvironmentVariableCollection>;
+    /**
+    * Sets an extension's environment variable collection.
+    */
     set(extensionIdentifier: string, collection: IEnvironmentVariableCollection): void;
+    /**
+    * Deletes an extension's environment variable collection.
+    */
     delete(extensionIdentifier: string): void;
 }

package/vscode/src/vs/workbench/contrib/terminal/common/terminal.service.d.ts

@@ -8,6 +8,9 @@ export declare const ITerminalProfileResolverService: import("../../../../platfo
 export interface ITerminalProfileResolverService {
     readonly _serviceBrand: undefined;
     readonly defaultProfileName: string | undefined;
+    /**
+    * Resolves the icon of a shell launch config if this will use the default profile
+    */
     resolveIcon(shellLaunchConfig: IShellLaunchConfig, os: OperatingSystem): void;
     resolveShellLaunchConfig(shellLaunchConfig: IShellLaunchConfig, options: IShellLaunchConfigResolveOptions): Promise<void>;
     getDefaultProfile(options: IShellLaunchConfigResolveOptions): Promise<ITerminalProfile>;

package/vscode/src/vs/workbench/contrib/testing/common/testCoverageService.service.d.ts

@@ -5,9 +5,25 @@ import { ITestRunTaskResults } from "@codingame/monaco-vscode-6845754f-e617-5ed9
 export declare const ITestCoverageService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<ITestCoverageService>;
 export interface ITestCoverageService {
     readonly _serviceBrand: undefined;
+    /**
+    * Settable observable that can be used to show the test coverage instance
+    * currently in the editor.
+    */
     readonly selected: IObservable<TestCoverage | undefined>;
+    /**
+    * Filter to per-test coverage from the given test ID.
+    */
     readonly filterToTest: ISettableObservable<TestId | undefined>;
+    /**
+    * Whether inline coverage is shown.
+    */
     readonly showInline: ISettableObservable<boolean>;
+    /**
+    * Opens a test coverage report from a task, optionally focusing it in the editor.
+    */
     openCoverage(task: ITestRunTaskResults, focus?: boolean): Promise<void>;
+    /**
+    * Closes any open coverage.
+    */
     closeCoverage(): void;
 }

package/vscode/src/vs/workbench/contrib/testing/common/testExplorerFilterState.service.d.ts

@@ -4,21 +4,52 @@ import { IObservableValue, MutableObservableValue } from "@codingame/monaco-vsco
 import { TestFilterTerm } from "@codingame/monaco-vscode-testing-service-override/vscode/vs/workbench/contrib/testing/common/testExplorerFilterState";
 export interface ITestExplorerFilterState {
     _serviceBrand: undefined;
+    /** Current filter text */
     readonly text: IObservableValue<string>;
+    /** Test ID the user wants to reveal in the explorer */
     readonly reveal: ISettableObservable<string | undefined>;
+    /** A test was selected in the explorer. */
     readonly onDidSelectTestInExplorer: Event<string | undefined>;
+    /** Event that fires when {@link focusInput} is invoked. */
     readonly onDidRequestInputFocus: Event<void>;
+    /**
+    * Glob list to filter for based on the {@link text}
+    */
     readonly globList: readonly {
         include: boolean;
         text: string;
     }[];
+    /**
+    * The user requested to filter including tags.
+    */
     readonly includeTags: ReadonlySet<string>;
+    /**
+    * The user requested to filter excluding tags.
+    */
     readonly excludeTags: ReadonlySet<string>;
+    /**
+    * Whether fuzzy searching is enabled.
+    */
     readonly fuzzy: MutableObservableValue<boolean>;
+    /**
+    * Focuses the filter input in the test explorer view.
+    */
     focusInput(): void;
+    /**
+    * Replaces the filter {@link text}.
+    */
     setText(text: string): void;
+    /**
+    * Sets whether the {@link text} is filtering for a special term.
+    */
     isFilteringFor(term: TestFilterTerm): boolean;
+    /**
+    * Sets whether the {@link text} includes a special filter term.
+    */
     toggleFilteringFor(term: TestFilterTerm, shouldFilter?: boolean): void;
+    /**
+    * Called when a test in the test explorer is selected.
+    */
     didSelectTestInExplorer(testId: string): void;
 }
 export declare const ITestExplorerFilterState: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<ITestExplorerFilterState>;

package/vscode/src/vs/workbench/contrib/testing/common/testId.d.ts

@@ -1,10 +1,19 @@
 export declare enum TestIdPathParts {
+    /** Delimiter for path parts in test IDs */
     Delimiter = "\0"
 }
+/**
+ * Enum for describing relative positions of tests. Similar to
+ * `node.compareDocumentPosition` in the DOM.
+ */
 export declare enum TestPosition {
+    /** a === b */
     IsSame = 0,
+    /** Neither a nor b are a child of one another. They may share a common parent, though. */
     Disconnected = 1,
+    /** b is a child of a */
     IsChild = 2,
+    /** b is a parent of a */
     IsParent = 3
 }
 type TestItemLike = {
@@ -12,32 +21,102 @@ type TestItemLike = {
     parent?: TestItemLike;
     _isRoot?: boolean;
 };
+/**
+ * The test ID is a stringifiable client that
+ */
 export declare class TestId {
     readonly path: readonly string[];
     private readonly viewEnd;
     private stringifed?;
+    /**
+     * Creates a test ID from an ext host test item.
+     */
     static fromExtHostTestItem(item: TestItemLike, rootId: string, parent?: TestItemLike | undefined): TestId;
+    /**
+     * Cheaply ets whether the ID refers to the root .
+     */
     static isRoot(idString: string): boolean;
+    /**
+     * Cheaply gets whether the ID refers to the root .
+     */
     static root(idString: string): string;
+    /**
+     * Creates a test ID from a serialized TestId instance.
+     */
     static fromString(idString: string): TestId;
+    /**
+     * Gets the ID resulting from adding b to the base ID.
+     */
     static join(base: TestId, b: string): TestId;
+    /**
+     * Splits a test ID into its parts.
+     */
     static split(idString: string): string[];
+    /**
+     * Gets the string ID resulting from adding b to the base ID.
+     */
     static joinToString(base: string | TestId, b: string): string;
+    /**
+     * Cheaply gets the parent ID of a test identified with the string.
+     */
     static parentId(idString: string): string | undefined;
+    /**
+     * Cheaply gets the local ID of a test identified with the string.
+     */
     static localId(idString: string): string;
+    /**
+     * Gets whether maybeChild is a child of maybeParent.
+     * todo@connor4312: review usages of this to see if using the WellDefinedPrefixTree is better
+     */
     static isChild(maybeParent: string, maybeChild: string): boolean;
+    /**
+     * Compares the position of the two ID strings.
+     * todo@connor4312: review usages of this to see if using the WellDefinedPrefixTree is better
+     */
     static compare(a: string, b: string): TestPosition;
     static getLengthOfCommonPrefix(length: number, getId: (i: number) => TestId): number;
     constructor(path: readonly string[], viewEnd?: number);
+    /**
+     * Gets the ID of the parent test.
+     */
     get rootId(): TestId;
+    /**
+     * Gets the ID of the parent test.
+     */
     get parentId(): TestId | undefined;
+    /**
+     * Gets the local ID of the current full test ID.
+     */
     get localId(): string;
+    /**
+     * Gets whether this ID refers to the root.
+     */
     get controllerId(): string;
+    /**
+     * Gets whether this ID refers to the root.
+     */
     get isRoot(): boolean;
+    /**
+     * Returns an iterable that yields IDs of all parent items down to and
+     * including the current item.
+     */
     idsFromRoot(): Generator<TestId, void, unknown>;
+    /**
+     * Returns an iterable that yields IDs of the current item up to the root
+     * item.
+     */
     idsToRoot(): Generator<TestId, void, unknown>;
+    /**
+     * Compares the other test ID with this one.
+     */
     compare(other: TestId | string): TestPosition;
+    /**
+     * Serializes the ID.
+     */
     toJSON(): string;
+    /**
+     * Serializes the ID to a string.
+     */
     toString(): string;
 }
 export {};

package/vscode/src/vs/workbench/contrib/testing/common/testItemCollection.d.ts

@@ -3,10 +3,16 @@ import { Disposable } from "../../../../base/common/lifecycle.js";
 import { ITestItem, ITestTag, TestItemExpandState, TestsDiff, TestsDiffOp } from "./testTypes.js";
 import { TestId } from "./testId.js";
 import { URI } from "../../../../base/common/uri.js";
+/**
+ * @private
+ */
 interface CollectionItem<T> {
     readonly fullId: TestId;
     actual: T;
     expand: TestItemExpandState;
+    /**
+     * Number of levels of items below this one that are expanded. May be infinite.
+     */
     expandLevels?: number;
     resolveBarrier?: Barrier;
 }
@@ -54,11 +60,17 @@ export interface ITestItemApi<T> {
     listener?: (evt: ExtHostTestItemEvent) => void;
 }
 export interface ITestItemCollectionOptions<T> {
+    /** Controller ID to use to prefix these test items. */
     controllerId: string;
+    /** Gets the document version at the given URI, if it's open */
     getDocumentVersion(uri: URI | undefined): number | undefined;
+    /** Gets API for the given test item, used to listen for events and set parents. */
     getApiFor(item: T): ITestItemApi<T>;
+    /** Converts the full test item to the common interface. */
     toITestItem(item: T): ITestItem;
+    /** Gets children for the item. */
     getChildren(item: T): ITestChildrenLike<T>;
+    /** Root to use for the new test collection. */
     root: T;
 }
 export interface ITestChildrenLike<T> extends Iterable<[
@@ -74,6 +86,9 @@ export interface ITestItemLike {
     uri?: URI;
     canResolveChildren: boolean;
 }
+/**
+ * Maintains a collection of test items for a single controller.
+ */
 export declare class TestItemCollection<T extends ITestItemLike> extends Disposable {
     private readonly options;
     private readonly debounceSendDiff;
@@ -84,11 +99,28 @@ export declare class TestItemCollection<T extends ITestItemLike> extends Disposa
     private readonly tags;
     protected diff: TestsDiff;
     constructor(options: ITestItemCollectionOptions<T>);
+    /**
+     * Handler used for expanding test items.
+     */
     set resolveHandler(handler: undefined | ((item: T | undefined) => void));
     get resolveHandler(): undefined | ((item: T | undefined) => void);
+    /**
+     * Fires when an operation happens that should result in a diff.
+     */
     readonly onDidGenerateDiff: import("../../../../base/common/event.js").Event<TestsDiff>;
+    /**
+     * Gets a diff of all changes that have been made, and clears the diff queue.
+     */
     collectDiff(): TestsDiff;
+    /**
+     * Pushes a new diff entry onto the collected diff list.
+     */
     pushDiff(diff: TestsDiffOp): void;
+    /**
+     * Expands the test and the given number of `levels` of children. If levels
+     * is < 0, then all children will be expanded. If it's 0, then only this
+     * item will be expanded.
+     */
     expand(testId: string, levels: number): Promise<void> | void;
     dispose(): void;
     private onTestItemEvent;
@@ -100,13 +132,30 @@ export declare class TestItemCollection<T extends ITestItemLike> extends Disposa
     private setItemParent;
     private connectItem;
     private connectItemAndChildren;
+    /**
+     * Updates the `expand` state of the item. Should be called whenever the
+     * resolved state of the item changes. Can automatically expand the item
+     * if requested by a consumer.
+     */
     private updateExpandability;
+    /**
+     * Expands all children of the item, "levels" deep. If levels is 0, only
+     * the children will be expanded. If it's 1, the children and their children
+     * will be expanded. If it's <0, it's a no-op.
+     */
     private expandChildren;
+    /**
+     * Calls `discoverChildren` on the item, refreshing all its tests.
+     */
     private resolveChildren;
     private pushExpandStateUpdate;
     private removeItem;
+    /**
+     * Immediately emits any pending diffs on the collection.
+     */
     flushDiff(): void;
 }
+/** Implementation of vscode.TestItemCollection */
 export interface ITestItemChildren<T extends ITestItemLike> extends Iterable<[
     string,
     T

package/vscode/src/vs/workbench/contrib/testing/common/testProfileService.service.d.ts

@@ -4,18 +4,54 @@ import { ITestRunProfile, ITestItem, TestRunProfileBitset, InternalTestItem } fr
 export declare const ITestProfileService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<ITestProfileService>;
 export interface ITestProfileService {
     readonly _serviceBrand: undefined;
+    /**
+    * Fired when any profile changes.
+    */
     readonly onDidChange: Event<void>;
+    /**
+    * Publishes a new test profile.
+    */
     addProfile(controller: IMainThreadTestController, profile: ITestRunProfile): void;
+    /**
+    * Updates an existing test run profile
+    */
     updateProfile(controllerId: string, profileId: number, update: Partial<ITestRunProfile>): void;
+    /**
+    * Removes a profile. If profileId is not given, all profiles
+    * for the given controller will be removed.
+    */
     removeProfile(controllerId: string, profileId?: number): void;
+    /**
+    * Gets capabilities for the given test, indicating whether
+    * there's any usable profiles available for those groups.
+    * @returns a bitset to use with {@link TestRunProfileBitset}
+    */
     capabilitiesForTest(test: ITestItem): number;
+    /**
+    * Configures a test profile.
+    */
     configure(controllerId: string, profileId: number): void;
+    /**
+    * Gets all registered controllers, grouping by controller.
+    */
     all(): Iterable<Readonly<{
         controller: IMainThreadTestController;
         profiles: ITestRunProfile[];
     }>>;
+    /**
+    * Gets the default profiles to be run for a given run group.
+    */
     getGroupDefaultProfiles(group: TestRunProfileBitset, controllerId?: string): ITestRunProfile[];
+    /**
+    * Sets the default profiles to be run for a given run group.
+    */
     setGroupDefaultProfiles(group: TestRunProfileBitset, profiles: ITestRunProfile[]): void;
+    /**
+    * Gets the profiles for a controller, in priority order.
+    */
     getControllerProfiles(controllerId: string): ITestRunProfile[];
+    /**
+    * Gets the preferred profile, if any, to run the test.
+    */
     getDefaultProfileForTest(group: TestRunProfileBitset, test: InternalTestItem): ITestRunProfile | undefined;
 }

package/vscode/src/vs/workbench/contrib/testing/common/testResultService.service.d.ts

@@ -5,13 +5,37 @@ import { ResolvedTestRunRequest, ExtensionRunTestsRequest, TestResultItem } from
 export declare const ITestResultService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<ITestResultService>;
 export interface ITestResultService {
     readonly _serviceBrand: undefined;
+    /**
+    * Fired after any results are added, removed, or completed.
+    */
     readonly onResultsChanged: Event<ResultChangeEvent>;
+    /**
+    * Fired when a test changed it state, or its computed state is updated.
+    */
     readonly onTestChanged: Event<TestResultItemChange>;
+    /**
+    * List of known test results.
+    */
     readonly results: ReadonlyArray<ITestResult>;
+    /**
+    * Discards all completed test results.
+    */
     clear(): void;
+    /**
+    * Creates a new, live test result.
+    */
     createLiveResult(req: ResolvedTestRunRequest | ExtensionRunTestsRequest): LiveTestResult;
+    /**
+    * Adds a new test result to the collection.
+    */
     push<T extends ITestResult>(result: T): T;
+    /**
+    * Looks up a set of test results by ID.
+    */
     getResult(resultId: string): ITestResult | undefined;
+    /**
+    * Looks up a test's most recent state, by its extension-assigned ID.
+    */
     getStateById(extId: string): [
         results: ITestResult,
         item: TestResultItem

package/vscode/src/vs/workbench/contrib/testing/common/testResultStorage.service.d.ts

@@ -1,7 +1,13 @@
 import { HydratedTestResult, ITestResult } from "@codingame/monaco-vscode-6845754f-e617-5ed9-8aaa-6ca3653a9532-common/vscode/vs/workbench/contrib/testing/common/testResult";
 export interface ITestResultStorage {
     _serviceBrand: undefined;
+    /**
+    * Retrieves the list of stored test results.
+    */
     read(): Promise<HydratedTestResult[]>;
+    /**
+    * Persists the list of test results.
+    */
     persist(results: ReadonlyArray<ITestResult>): Promise<void>;
 }
 export declare const ITestResultStorage: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<unknown>;