@codingame/monaco-vscode-api 20.1.1 → 20.2.1

package/vscode/src/vs/workbench/contrib/debug/common/debug.d.ts

@@ -206,6 +206,10 @@ export interface IDebugSessionOptions {
     suppressDebugToolbar?: boolean;
     suppressDebugStatusbar?: boolean;
     suppressDebugView?: boolean;
+    /**
+     * Set if the debug session is correlated with a test run. Stopping/restarting
+     * the session will instead stop/restart the test run.
+     */
     testRun?: IDebugTestRunReference;
 }
 export interface IDataBreakpointInfoResponse {
@@ -241,18 +245,56 @@ export interface IErrorMemoryRange extends IMemoryRange {
     type: MemoryRangeType.Error;
     error: string;
 }
+/**
+ * Union type of memory that can be returned from read(). Since a read request
+ * could encompass multiple previously-read ranges, multiple of these types
+ * are possible to return.
+ */
 export type MemoryRange = IValidMemoryRange | IUnreadableMemoryRange | IErrorMemoryRange;
 export declare const DEBUG_MEMORY_SCHEME = "vscode-debug-memory";
+/**
+ * An IMemoryRegion corresponds to a contiguous range of memory referred to
+ * by a DAP `memoryReference`.
+ */
 export interface IMemoryRegion extends IDisposable {
+    /**
+     * Event that fires when memory changes. Can be a result of memory events or
+     * `write` requests.
+     */
     readonly onDidInvalidate: Event<IMemoryInvalidationEvent>;
+    /**
+     * Whether writes are supported on this memory region.
+     */
     readonly writable: boolean;
+    /**
+     * Requests memory ranges from the debug adapter. It returns a list of memory
+     * ranges that overlap (but may exceed!) the given offset. Use the `offset`
+     * and `length` of each range for display.
+     */
     read(fromOffset: number, toOffset: number): Promise<MemoryRange[]>;
+    /**
+     * Writes memory to the debug adapter at the given offset.
+     */
     write(offset: number, data: VSBuffer): Promise<number>;
 }
+/** Data that can be inserted in {@link IDebugSession.appendToRepl} */
 export interface INewReplElementData {
+    /**
+     * Output string to display
+     */
     output: string;
+    /**
+     * Expression data to display. Will result in the item being expandable in
+     * the REPL. Its value will be used if {@link output} is not provided.
+     */
     expression?: IExpression;
+    /**
+     * Output severity.
+     */
     sev: severity;
+    /**
+     * Originating location.
+     */
     source?: IReplElementSource;
 }
 export interface IDebugEvaluatePosition {
@@ -283,6 +325,7 @@ export interface IDebugSession extends ITreeElement, IDisposable {
     readonly suppressDebugStatusbar: boolean;
     readonly suppressDebugView: boolean;
     readonly lifecycleManagedByParent: boolean;
+    /** Test run this debug session was spawned by */
     readonly correlatedTestRun?: LiveTestResult;
     setSubId(subId: string | undefined): void;
     getMemory(memoryReference: string): IMemoryRegion;
@@ -305,11 +348,14 @@ export interface IDebugSession extends ITreeElement, IDisposable {
     removeReplExpressions(): void;
     addReplExpression(stackFrame: IStackFrame | undefined, name: string): Promise<void>;
     appendToRepl(data: INewReplElementData): void;
+    /** Cancel any associated test run set through the DebugSessionOptions */
     cancelCorrelatedTestRun(): void;
     readonly onDidEndAdapter: Event<AdapterEndEvent | undefined>;
     readonly onDidChangeState: Event<void>;
     readonly onDidChangeReplElements: Event<IReplElement | undefined>;
+    /** DA capabilities. Set only when there is a running session available. */
     readonly capabilities: DebugProtocol.Capabilities;
+    /** DA capabilities. These are retained on the session even after is implementation ends. */
     readonly rememberedCapabilities?: DebugProtocol.Capabilities;
     readonly onDidLoadedSource: Event<LoadedSourceEvent>;
     readonly onDidCustomEvent: Event<DebugProtocol.Event>;
@@ -361,15 +407,44 @@ export interface IDebugSession extends ITreeElement, IDisposable {
     goto(threadId: number, targetId: number): Promise<DebugProtocol.GotoResponse | undefined>;
 }
 export interface IThread extends ITreeElement {
+    /**
+     * Process the thread belongs to
+     */
     readonly session: IDebugSession;
+    /**
+     * Id of the thread generated by the debug adapter backend.
+     */
     readonly threadId: number;
+    /**
+     * Name of the thread.
+     */
     readonly name: string;
+    /**
+     * Information about the current thread stop event. Undefined if thread is not stopped.
+     */
     readonly stoppedDetails: IRawStoppedDetails | undefined;
+    /**
+     * Information about the exception if an 'exception' stopped event raised and DA supports the 'exceptionInfo' request, otherwise undefined.
+     */
     readonly exceptionInfo: Promise<IExceptionInfo | undefined>;
     readonly stateLabel: string;
+    /**
+     * Gets the callstack if it has already been received from the debug
+     * adapter.
+     */
     getCallStack(): ReadonlyArray<IStackFrame>;
+    /**
+     * Gets the top stack frame that is not hidden if the callstack has already been received from the debug adapter
+     */
     getTopStackFrame(): IStackFrame | undefined;
+    /**
+     * Invalidates the callstack cache
+     */
     clearCallStack(): void;
+    /**
+     * Indicates whether this thread is stopped. The callstack for stopped
+     * threads can be retrieved from the debug adapter.
+     */
     readonly stopped: boolean;
     next(granularity?: DebugProtocol.SteppingGranularity): Promise<any>;
     stepIn(granularity?: DebugProtocol.SteppingGranularity): Promise<any>;
@@ -436,13 +511,17 @@ export interface IBaseBreakpoint extends IEnablement {
     readonly verified: boolean;
     readonly supported: boolean;
     readonly message?: string;
+    /** The preferred mode of the breakpoint from {@link DebugProtocol.BreakpointMode} */
     readonly mode?: string;
+    /** The preferred mode label of the breakpoint from {@link DebugProtocol.BreakpointMode} */
     readonly modeLabel?: string;
     readonly sessionsThatVerified: string[];
     getIdFromAdapter(sessionId: string): number | undefined;
 }
 export interface IBreakpoint extends IBaseBreakpoint {
+    /** URI where the breakpoint was first set by the user. */
     readonly originalUri: uri;
+    /** URI where the breakpoint is currently shown; may be moved by debugger */
     readonly uri: uri;
     readonly lineNumber: number;
     readonly endLineNumber?: number;
@@ -453,9 +532,13 @@ export interface IBreakpoint extends IBaseBreakpoint {
         lineNumber: number;
         column: number | undefined;
     };
+    /** An ID of the breakpoint that triggers this breakpoint. */
     readonly triggeredBy?: string;
+    /** Pending on the trigger breakpoint, which means this breakpoint is not yet sent to DA */
     readonly pending: boolean;
+    /** Marks that a session did trigger the breakpoint. */
     setSessionDidTrigger(sessionId: string, didTrigger?: boolean): void;
+    /** Gets whether the `triggeredBy` condition has been met in the given sesison ID. */
     getSessionDidTrigger(sessionId: string): boolean;
     toDAP(): DebugProtocol.SourceBreakpoint;
 }
@@ -472,6 +555,11 @@ export declare enum DataBreakpointSetType {
     Variable = 0,
     Address = 1
 }
+/**
+ * Source for a data breakpoint. A data breakpoint on a variable always has a
+ * `dataId` because it cannot reference that variable globally, but addresses
+ * can request info repeated and use session-specific data.
+ */
 export type DataBreakpointSource = {
     type: DataBreakpointSetType.Variable;
     dataId: string;
@@ -490,6 +578,7 @@ export interface IDataBreakpoint extends IBaseBreakpoint {
 export interface IInstructionBreakpoint extends IBaseBreakpoint {
     readonly instructionReference: string;
     readonly offset?: number;
+    /** Original instruction memory address; display purposes only */
     readonly address: bigint;
     toDAP(): DebugProtocol.InstructionBreakpoint;
 }
@@ -500,12 +589,22 @@ export interface IExceptionInfo {
     readonly details?: DebugProtocol.ExceptionDetails;
 }
 export interface IViewModel extends ITreeElement {
+    /**
+     * Returns the focused debug session or undefined if no session is stopped.
+     */
     readonly focusedSession: IDebugSession | undefined;
+    /**
+     * Returns the focused thread or undefined if no thread is stopped.
+     */
     readonly focusedThread: IThread | undefined;
+    /**
+     * Returns the focused stack frame or undefined if there are no stack frames.
+     */
     readonly focusedStackFrame: IStackFrame | undefined;
     setVisualizedExpression(original: IExpression, visualized: IExpression & {
         treeId: string;
     } | undefined): void;
+    /** Returns the visualized expression if loaded, or a tree it should be visualized with, or undefined */
     getVisualizedExpression(expression: IExpression): IExpression | string | undefined;
     getSelectedExpression(): {
         expression: IExpression;
@@ -530,6 +629,10 @@ export interface IViewModel extends ITreeElement {
         settingWatch: boolean;
     } | undefined>;
     onDidEvaluateLazyExpression: Event<IExpressionContainer>;
+    /**
+     * Fired when `setVisualizedExpression`, to migrate elements currently
+     * rendered as `original` to the `replacement`.
+     */
     onDidChangeVisualization: Event<{
         original: IExpression;
         replacement: IExpression;
@@ -554,7 +657,14 @@ export interface IDebugModel extends ITreeElement {
     areBreakpointsActivated(): boolean;
     getFunctionBreakpoints(): ReadonlyArray<IFunctionBreakpoint>;
     getDataBreakpoints(): ReadonlyArray<IDataBreakpoint>;
+    /**
+     * Returns list of all exception breakpoints.
+     */
     getExceptionBreakpoints(): ReadonlyArray<IExceptionBreakpoint>;
+    /**
+     * Returns list of exception breakpoints for the given session
+     * @param sessionId Session id. If falsy, returns the breakpoints from the last set fallback session.
+     */
     getExceptionBreakpointsForSession(sessionId?: string): ReadonlyArray<IExceptionBreakpoint>;
     getInstructionBreakpoints(): ReadonlyArray<IInstructionBreakpoint>;
     getWatchExpressions(): ReadonlyArray<IExpression & IEvaluate>;
@@ -562,10 +672,19 @@ export interface IDebugModel extends ITreeElement {
     getBreakpointModes(forBreakpointType: "source" | "exception" | "data" | "instruction"): DebugProtocol.BreakpointMode[];
     onDidChangeBreakpoints: Event<IBreakpointsChangeEvent | undefined>;
     onDidChangeCallStack: Event<void>;
+    /**
+     * The expression has been added, removed, or repositioned.
+     */
     onDidChangeWatchExpressions: Event<IExpression | undefined>;
+    /**
+     * The expression's value has changed.
+     */
     onDidChangeWatchExpressionValue: Event<IExpression | undefined>;
     fetchCallstack(thread: IThread, levels?: number): Promise<void>;
 }
+/**
+ * An event describing a change to the set of [breakpoints](#debug.Breakpoint).
+ */
 export interface IBreakpointsChangeEvent {
     added?: Array<IBreakpoint | IFunctionBreakpoint | IDataBreakpoint | IInstructionBreakpoint>;
     removed?: Array<IBreakpoint | IFunctionBreakpoint | IDataBreakpoint | IInstructionBreakpoint>;
@@ -732,7 +851,13 @@ export interface IBreakpointContribution {
     when?: string;
 }
 export declare enum DebugConfigurationProviderTriggerKind {
+    /**
+     *	`DebugConfigurationProvider.provideDebugConfigurations` is called to provide the initial debug configurations for a newly created launch.json.
+     */
     Initial = 1,
+    /**
+     * `DebugConfigurationProvider.provideDebugConfigurations` is called to provide dynamically generated debug configurations when the user asks for them through the UI (e.g. via the "Select and Start Debugging" command).
+     */
     Dynamic = 2
 }
 export interface IDebugConfigurationProvider {
@@ -750,6 +875,9 @@ interface ITerminalLauncher {
     runInTerminal(args: DebugProtocol.RunInTerminalRequestArguments, sessionId: string): Promise<number | undefined>;
 }
 export interface IConfigurationManager {
+    /**
+     * Returns an object containing the selected launch configuration and the selected configuration name. Both these fields can be null (no folder workspace).
+     */
     readonly selectedConfiguration: {
         launch: ILaunch | undefined;
         getConfig: () => Promise<IConfig | undefined>;
@@ -771,7 +899,13 @@ export interface IConfigurationManager {
         name: string;
         type: string;
     }[];
+    /**
+     * Allows to register on change of selected debug configuration.
+     */
     onDidSelectConfiguration: Event<void>;
+    /**
+     * Allows to register on change of selected debug configuration.
+     */
     onDidChangeConfigurationProviders: Event<void>;
     hasDebugConfigurationProvider(debugType: string, triggerKind?: DebugConfigurationProviderTriggerKind): boolean;
     getDynamicProviders(): Promise<{
@@ -822,13 +956,40 @@ export interface IGuessedDebugger {
     };
 }
 export interface ILaunch {
+    /**
+     * Resource pointing to the launch.json this object is wrapping.
+     */
     readonly uri: uri;
+    /**
+     * Name of the launch.
+     */
     readonly name: string;
+    /**
+     * Workspace of the launch. Can be undefined.
+     */
     readonly workspace: IWorkspaceFolder | undefined;
+    /**
+     * Should this launch be shown in the debug dropdown.
+     */
     readonly hidden: boolean;
+    /**
+     * Returns a configuration with the specified name.
+     * Returns undefined if there is no configuration with the specified name.
+     */
     getConfiguration(name: string): IConfig | undefined;
+    /**
+     * Returns a compound with the specified name.
+     * Returns undefined if there is no compound with the specified name.
+     */
     getCompound(name: string): ICompound | undefined;
+    /**
+     * Returns the names of all configurations and compounds.
+     * Ignores configurations which are invalid.
+     */
     getConfigurationNames(ignoreCompoundsAndPresentation?: boolean): string[];
+    /**
+     * Opens the launch.json file. Creates if it does not exist.
+     */
     openConfigFile(options: {
         preserveFocus: boolean;
         type?: string;

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

@@ -6,57 +6,187 @@ import { IFunctionBreakpointOptions, IDataBreakpointOptions, IInstructionBreakpo
 export declare const IDebugService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IDebugService>;
 export interface IDebugService {
     readonly _serviceBrand: undefined;
+    /**
+    * Gets the current debug state.
+    */
     readonly state: State;
     readonly initializingOptions?: IDebugSessionOptions | undefined;
+    /**
+    * Allows to register on debug state changes.
+    */
     onDidChangeState: Event<State>;
+    /**
+    * Allows to register on sessions about to be created (not yet fully initialised).
+    * This is fired exactly one time for any given session.
+    */
     onWillNewSession: Event<IDebugSession>;
+    /**
+    * Fired when a new debug session is started. This may fire multiple times
+    * for a single session due to restarts.
+    */
     onDidNewSession: Event<IDebugSession>;
+    /**
+    * Allows to register on end session events.
+    *
+    * Contains a boolean indicating whether the session will restart. If restart
+    * is true, the session should not considered to be dead yet.
+    */
     onDidEndSession: Event<{
         session: IDebugSession;
         restart: boolean;
     }>;
+    /**
+    * Gets the configuration manager.
+    */
     getConfigurationManager(): IConfigurationManager;
+    /**
+    * Gets the adapter manager.
+    */
     getAdapterManager(): IAdapterManager;
+    /**
+    * Sets the focused stack frame and evaluates all expressions against the newly focused stack frame,
+    */
     focusStackFrame(focusedStackFrame: IStackFrame | undefined, thread?: IThread, session?: IDebugSession, options?: {
         explicit?: boolean;
         preserveFocus?: boolean;
         sideBySide?: boolean;
         pinned?: boolean;
     }): Promise<void>;
+    /**
+    * Returns true if breakpoints can be set for a given editor model. Depends on mode.
+    */
     canSetBreakpointsIn(model: EditorIModel): boolean;
+    /**
+    * Adds new breakpoints to the model for the file specified with the uri. Notifies debug adapter of breakpoint changes.
+    */
     addBreakpoints(uri: uri, rawBreakpoints: IBreakpointData[], ariaAnnounce?: boolean): Promise<IBreakpoint[]>;
+    /**
+    * Updates the breakpoints.
+    */
     updateBreakpoints(originalUri: uri, data: Map<string, IBreakpointUpdateData>, sendOnResourceSaved: boolean): Promise<void>;
+    /**
+    * Enables or disables all breakpoints. If breakpoint is passed only enables or disables the passed breakpoint.
+    * Notifies debug adapter of breakpoint changes.
+    */
     enableOrDisableBreakpoints(enable: boolean, breakpoint?: IEnablement): Promise<void>;
+    /**
+    * Sets the global activated property for all breakpoints.
+    * Notifies debug adapter of breakpoint changes.
+    */
     setBreakpointsActivated(activated: boolean): Promise<void>;
+    /**
+    * Removes all breakpoints. If id is passed only removes the breakpoint associated with that id.
+    * Notifies debug adapter of breakpoint changes.
+    */
     removeBreakpoints(id?: string): Promise<any>;
+    /**
+    * Adds a new function breakpoint for the given name.
+    */
     addFunctionBreakpoint(opts?: IFunctionBreakpointOptions, id?: string): void;
+    /**
+    * Updates an already existing function breakpoint.
+    * Notifies debug adapter of breakpoint changes.
+    */
     updateFunctionBreakpoint(id: string, update: {
         name?: string;
         hitCondition?: string;
         condition?: string;
     }): Promise<void>;
+    /**
+    * Removes all function breakpoints. If id is passed only removes the function breakpoint with the passed id.
+    * Notifies debug adapter of breakpoint changes.
+    */
     removeFunctionBreakpoints(id?: string): Promise<void>;
+    /**
+    * Adds a new data breakpoint.
+    */
     addDataBreakpoint(opts: IDataBreakpointOptions): Promise<void>;
+    /**
+    * Updates an already existing data breakpoint.
+    * Notifies debug adapter of breakpoint changes.
+    */
     updateDataBreakpoint(id: string, update: {
         hitCondition?: string;
         condition?: string;
     }): Promise<void>;
+    /**
+    * Removes all data breakpoints. If id is passed only removes the data breakpoint with the passed id.
+    * Notifies debug adapter of breakpoint changes.
+    */
     removeDataBreakpoints(id?: string): Promise<void>;
+    /**
+    * Adds a new instruction breakpoint.
+    */
     addInstructionBreakpoint(opts: IInstructionBreakpointOptions): Promise<void>;
+    /**
+    * Removes all instruction breakpoints. If address is passed only removes the instruction breakpoint with the passed address.
+    * The address should be the address string supplied by the debugger from the "Disassemble" request.
+    * Notifies debug adapter of breakpoint changes.
+    */
     removeInstructionBreakpoints(instructionReference?: string, offset?: number): Promise<void>;
     setExceptionBreakpointCondition(breakpoint: IExceptionBreakpoint, condition: string | undefined): Promise<void>;
+    /**
+    * Creates breakpoints based on the sesison filter options. This will create
+    * disabled breakpoints (or enabled, if the filter indicates it's a default)
+    * for each filter provided in the session.
+    */
     setExceptionBreakpointsForSession(session: IDebugSession, filters: DebugProtocol.ExceptionBreakpointsFilter[]): void;
+    /**
+    * Sends all breakpoints to the passed session.
+    * If session is not passed, sends all breakpoints to each session.
+    */
     sendAllBreakpoints(session?: IDebugSession): Promise<any>;
+    /**
+    * Sends breakpoints of the given source to the passed session.
+    */
     sendBreakpoints(modelUri: uri, sourceModified?: boolean, session?: IDebugSession): Promise<any>;
+    /**
+    * Adds a new watch expression and evaluates it against the debug adapter.
+    */
     addWatchExpression(name?: string): void;
+    /**
+    * Renames a watch expression and evaluates it against the debug adapter.
+    */
     renameWatchExpression(id: string, newName: string): void;
+    /**
+    * Moves a watch expression to a new possition. Used for reordering watch expressions.
+    */
     moveWatchExpression(id: string, position: number): void;
+    /**
+    * Removes all watch expressions. If id is passed only removes the watch expression with the passed id.
+    */
     removeWatchExpressions(id?: string): void;
+    /**
+    * Starts debugging. If the configOrName is not passed uses the selected configuration in the debug dropdown.
+    * Also saves all files, manages if compounds are present in the configuration
+    * and resolveds configurations via DebugConfigurationProviders.
+    *
+    * Returns true if the start debugging was successful. For compound launches, all configurations have to start successfully for it to return success.
+    * On errors the startDebugging will throw an error, however some error and cancelations are handled and in that case will simply return false.
+    */
     startDebugging(launch: ILaunch | undefined, configOrName?: IConfig | string, options?: IDebugSessionOptions, saveBeforeStart?: boolean): Promise<boolean>;
+    /**
+    * Restarts a session or creates a new one if there is no active session.
+    */
     restartSession(session: IDebugSession, restartData?: any): Promise<any>;
+    /**
+    * Stops the session. If no session is specified then all sessions are stopped.
+    */
     stopSession(session: IDebugSession | undefined, disconnect?: boolean, suspend?: boolean): Promise<any>;
+    /**
+    * Makes unavailable all sources with the passed uri. Source will appear as grayed out in callstack view.
+    */
     sourceIsNotAvailable(uri: uri): void;
+    /**
+    * Gets the current debug model.
+    */
     getModel(): IDebugModel;
+    /**
+    * Gets the current view model.
+    */
     getViewModel(): IViewModel;
+    /**
+    * Resumes execution and pauses until the given position is reached.
+    */
     runTo(uri: uri, lineNumber: number, column?: number): Promise<void>;
 }

package/vscode/src/vs/workbench/contrib/debug/common/debugUtils.d.ts

@@ -9,12 +9,23 @@ import { ILanguageFeaturesService } from "../../../../editor/common/services/lan
 export declare function formatPII(value: string, excludePII: boolean, args: {
     [key: string]: string;
 } | undefined): string;
+/**
+ * Filters exceptions (keys marked with "!") from the given object. Used to
+ * ensure exception data is not sent on web remotes, see #97628.
+ */
 export declare function filterExceptionsFromTelemetry<T extends {
     [key: string]: unknown;
 }>(data: T): Partial<T>;
 export declare function isSessionAttach(session: IDebugSession): boolean;
+/**
+ * Returns the session or any parent which is an extension host debug session.
+ * Returns undefined if there's none.
+ */
 export declare function getExtensionHostDebugSession(session: IDebugSession): IDebugSession | void;
 export declare function isDebuggerMainContribution(dbg: IDebuggerContribution): string | undefined;
+/**
+ * Note- uses 1-indexed numbers
+ */
 export declare function getExactExpressionStartAndEnd(lineContent: string, looseStart: number, looseEnd: number): {
     start: number;
     end: number;

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

@@ -6,10 +6,28 @@ import { DebugVisualizer, VisualizerHandle, VisualizerTreeHandle } from "@coding
 export declare const IDebugVisualizerService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IDebugVisualizerService>;
 export interface IDebugVisualizerService {
     _serviceBrand: undefined;
+    /**
+    * Gets visualizers applicable for the given Expression.
+    */
     getApplicableFor(expression: IExpression, token: CancellationToken): Promise<IReference<DebugVisualizer[]>>;
+    /**
+    * Registers a new visualizer (called from the main thread debug service)
+    */
     register(handle: VisualizerHandle): IDisposable;
+    /**
+    * Registers a new visualizer tree.
+    */
     registerTree(treeId: string, handle: VisualizerTreeHandle): IDisposable;
+    /**
+    * Sets that a certa tree should be used for the visualized node
+    */
     getVisualizedNodeFor(treeId: string, expr: IExpression): Promise<VisualizedExpression | undefined>;
+    /**
+    * Gets children for a visualized tree node.
+    */
     getVisualizedChildren(session: IDebugSession | undefined, treeId: string, treeElementId: number): Promise<IExpression[]>;
+    /**
+    * Gets children for a visualized tree node.
+    */
     editTreeItem(treeId: string, item: IDebugVisualizationTreeItem, newValue: string): Promise<void>;
 }

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

@@ -5,7 +5,14 @@ import { IExternalOpenerProvider, IExternalUriOpener } from "@codingame/monaco-v
 export declare const IExternalUriOpenerService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IExternalUriOpenerService>;
 export interface IExternalUriOpenerService {
     readonly _serviceBrand: undefined;
+    /**
+    * Registers a provider for external resources openers.
+    */
     registerExternalOpenerProvider(provider: IExternalOpenerProvider): IDisposable;
+    /**
+    * Get the configured IExternalUriOpener for the uri.
+    * If there is no opener configured, then returns the first opener that can handle the uri.
+    */
     getOpener(uri: URI, ctx: {
         sourceUri: URI;
         preferredOpenerId?: string;

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

@@ -29,6 +29,10 @@ export interface IExplorerService {
         confirmBeforeUndo?: boolean;
         progressLocation?: ProgressLocation.Explorer | ProgressLocation.Window;
     }): Promise<void>;
+    /**
+    * Selects and reveal the file element provided by the given resource if its found in the explorer.
+    * Will try to resolve the path in case the explorer is not yet expanded to the file yet.
+    */
     select(resource: URI, reveal?: boolean | string): Promise<void>;
     registerView(contextAndRefreshProvider: IExplorerView): void;
 }

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

@@ -4,6 +4,9 @@ import { DefaultLogLevels } from "@codingame/monaco-vscode-log-service-override/
 export declare const IDefaultLogLevelsService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IDefaultLogLevelsService>;
 export interface IDefaultLogLevelsService {
     readonly _serviceBrand: undefined;
+    /**
+    * An event which fires when default log levels are changed
+    */
     readonly onDidChangeDefaultLogLevels: Event<void>;
     getDefaultLogLevels(): Promise<DefaultLogLevels>;
     getDefaultLogLevel(extensionId?: string): Promise<LogLevel>;

package/vscode/src/vs/workbench/contrib/mcp/common/mcpRegistryTypes.d.ts

@@ -4,6 +4,7 @@ import { IObservable } from "../../../../base/common/observable.js";
 import { ILogger, LogLevel } from "../../../../platform/log/common/log.js";
 import { McpCollectionDefinition, McpCollectionReference, McpConnectionState, McpDefinitionReference, McpServerDefinition, McpServerLaunch, McpStartServerInteraction } from "./mcpTypes.js";
 import { MCP } from "./modelContextProtocol.js";
+/** Message transport to a single MCP server. */
 export interface IMcpMessageTransport extends IDisposable {
     readonly state: IObservable<McpConnectionState>;
     readonly onDidLog: Event<{
@@ -15,6 +16,7 @@ export interface IMcpMessageTransport extends IDisposable {
     stop(): void;
 }
 export interface IMcpHostDelegate {
+    /** Priority for this delegate, delegates are tested in descending priority order */
     readonly priority: number;
     waitForInitialProviderPromises(): Promise<void>;
     canStart(collectionDefinition: McpCollectionDefinition, serverDefinition: McpServerDefinition): boolean;
@@ -25,10 +27,22 @@ export interface IMcpResolveConnectionOptions {
     interaction?: McpStartServerInteraction;
     collectionRef: McpCollectionReference;
     definitionRef: McpDefinitionReference;
+    /** A reference (on the server) to its last nonce where trust was given. */
     trustNonceBearer: {
         trustedAtNonce: string | undefined;
     };
+    /**
+     * When to trigger the trust prompt.
+     * - only-new: only prompt for servers that are not previously explicitly untrusted (default)
+     * - all-untrusted: prompt for all servers that are not trusted
+     * - never: don't prompt, fail silently when trying to start an untrusted server
+     */
     promptType?: "only-new" | "all-untrusted" | "never";
+    /**
+     * Automatically trust if changed. This should ONLY be set for afforances that
+     * ensure the user sees the config before it gets started (e.g. code lenses)
+     */
     autoTrustChanges?: boolean;
+    /** If set, try to launch with debugging when dev mode is configured */
     debug?: boolean;
 }