@codingame/monaco-vscode-api 20.1.1 → 20.2.1

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

@@ -7,23 +7,91 @@ import { IFileSystemProviderRegistrationEvent, IFileSystemProviderCapabilitiesCh
 export declare const IFileService: import("../../instantiation/common/instantiation.js").ServiceIdentifier<IFileService>;
 export interface IFileService {
     readonly _serviceBrand: undefined;
+    /**
+    * An event that is fired when a file system provider is added or removed
+    */
     readonly onDidChangeFileSystemProviderRegistrations: Event<IFileSystemProviderRegistrationEvent>;
+    /**
+    * An event that is fired when a registered file system provider changes its capabilities.
+    */
     readonly onDidChangeFileSystemProviderCapabilities: Event<IFileSystemProviderCapabilitiesChangeEvent>;
+    /**
+    * An event that is fired when a file system provider is about to be activated. Listeners
+    * can join this event with a long running promise to help in the activation process.
+    */
     readonly onWillActivateFileSystemProvider: Event<IFileSystemProviderActivationEvent>;
+    /**
+    * Registers a file system provider for a certain scheme.
+    */
     registerProvider(scheme: string, provider: IFileSystemProvider): IDisposable;
+    /**
+    * Returns a file system provider for a certain scheme.
+    */
     getProvider(scheme: string): IFileSystemProvider | undefined;
+    /**
+    * Tries to activate a provider with the given scheme.
+    */
     activateProvider(scheme: string): Promise<void>;
+    /**
+    * Checks if this file service can handle the given resource by
+    * first activating any extension that wants to be activated
+    * on the provided resource scheme to include extensions that
+    * contribute file system providers for the given resource.
+    */
     canHandleResource(resource: URI): Promise<boolean>;
+    /**
+    * Checks if the file service has a registered provider for the
+    * provided resource.
+    *
+    * Note: this does NOT account for contributed providers from
+    * extensions that have not been activated yet. To include those,
+    * consider to call `await fileService.canHandleResource(resource)`.
+    */
     hasProvider(resource: URI): boolean;
+    /**
+    * Checks if the provider for the provided resource has the provided file system capability.
+    */
     hasCapability(resource: URI, capability: FileSystemProviderCapabilities): boolean;
+    /**
+    * List the schemes and capabilities for registered file system providers
+    */
     listCapabilities(): Iterable<{
         scheme: string;
         capabilities: FileSystemProviderCapabilities;
     }>;
+    /**
+    * Allows to listen for file changes. The event will fire for every file within the opened workspace
+    * (if any) as well as all files that have been watched explicitly using the #watch() API.
+    */
     readonly onDidFilesChange: Event<FileChangesEvent>;
+    /**
+    * An event that is fired upon successful completion of a certain file operation.
+    */
     readonly onDidRunOperation: Event<FileOperationEvent>;
+    /**
+    * Resolve the properties of a file/folder identified by the resource. For a folder, children
+    * information is resolved as well depending on the provided options. Use `stat()` method if
+    * you do not need children information.
+    *
+    * If the optional parameter "resolveTo" is specified in options, the stat service is asked
+    * to provide a stat object that should contain the full graph of folders up to all of the
+    * target resources.
+    *
+    * If the optional parameter "resolveSingleChildDescendants" is specified in options,
+    * the stat service is asked to automatically resolve child folders that only
+    * contain a single element.
+    *
+    * If the optional parameter "resolveMetadata" is specified in options,
+    * the stat will contain metadata information such as size, mtime and etag.
+    */
     resolve(resource: URI, options: IResolveMetadataFileOptions): Promise<IFileStatWithMetadata>;
     resolve(resource: URI, options?: IResolveFileOptions): Promise<IFileStat>;
+    /**
+    * Same as `resolve()` but supports resolving multiple resources in parallel.
+    *
+    * If one of the resolve targets fails to resolve returns a fake `IFileStat` instead of
+    * making the whole call fail.
+    */
     resolveAll(toResolve: {
         resource: URI;
         options: IResolveMetadataFileOptions;
@@ -32,26 +100,126 @@ export interface IFileService {
         resource: URI;
         options?: IResolveFileOptions;
     }[]): Promise<IFileStatResult[]>;
+    /**
+    * Same as `resolve()` but without resolving the children of a folder if the
+    * resource is pointing to a folder.
+    */
     stat(resource: URI): Promise<IFileStatWithPartialMetadata>;
+    /**
+    * Attempts to resolve the real path of the provided resource. The real path can be
+    * different from the resource path for example when it is a symlink.
+    *
+    * Will return `undefined` if the real path cannot be resolved.
+    */
     realpath(resource: URI): Promise<URI | undefined>;
+    /**
+    * Finds out if a file/folder identified by the resource exists.
+    */
     exists(resource: URI): Promise<boolean>;
+    /**
+    * Read the contents of the provided resource unbuffered.
+    */
     readFile(resource: URI, options?: IReadFileOptions, token?: CancellationToken): Promise<IFileContent>;
+    /**
+    * Read the contents of the provided resource buffered as stream.
+    */
     readFileStream(resource: URI, options?: IReadFileStreamOptions, token?: CancellationToken): Promise<IFileStreamContent>;
+    /**
+    * Updates the content replacing its previous value.
+    *
+    * Emits a `FileOperation.WRITE` file operation event when successful.
+    */
     writeFile(resource: URI, bufferOrReadableOrStream: VSBuffer | VSBufferReadable | VSBufferReadableStream, options?: IWriteFileOptions): Promise<IFileStatWithMetadata>;
+    /**
+    * Moves the file/folder to a new path identified by the resource.
+    *
+    * The optional parameter overwrite can be set to replace an existing file at the location.
+    *
+    * Emits a `FileOperation.MOVE` file operation event when successful.
+    */
     move(source: URI, target: URI, overwrite?: boolean): Promise<IFileStatWithMetadata>;
+    /**
+    * Find out if a move operation is possible given the arguments. No changes on disk will
+    * be performed. Returns an Error if the operation cannot be done.
+    */
     canMove(source: URI, target: URI, overwrite?: boolean): Promise<Error | true>;
+    /**
+    * Copies the file/folder to a path identified by the resource. A folder is copied
+    * recursively.
+    *
+    * Emits a `FileOperation.COPY` file operation event when successful.
+    */
     copy(source: URI, target: URI, overwrite?: boolean): Promise<IFileStatWithMetadata>;
+    /**
+    * Find out if a copy operation is possible given the arguments. No changes on disk will
+    * be performed. Returns an Error if the operation cannot be done.
+    */
     canCopy(source: URI, target: URI, overwrite?: boolean): Promise<Error | true>;
+    /**
+    * Clones a file to a path identified by the resource. Folders are not supported.
+    *
+    * If the target path exists, it will be overwritten.
+    */
     cloneFile(source: URI, target: URI): Promise<void>;
+    /**
+    * Creates a new file with the given path and optional contents. The returned promise
+    * will have the stat model object as a result.
+    *
+    * The optional parameter content can be used as value to fill into the new file.
+    *
+    * Emits a `FileOperation.CREATE` file operation event when successful.
+    */
     createFile(resource: URI, bufferOrReadableOrStream?: VSBuffer | VSBufferReadable | VSBufferReadableStream, options?: ICreateFileOptions): Promise<IFileStatWithMetadata>;
+    /**
+    * Find out if a file create operation is possible given the arguments. No changes on disk will
+    * be performed. Returns an Error if the operation cannot be done.
+    */
     canCreateFile(resource: URI, options?: ICreateFileOptions): Promise<Error | true>;
+    /**
+    * Creates a new folder with the given path. The returned promise
+    * will have the stat model object as a result.
+    *
+    * Emits a `FileOperation.CREATE` file operation event when successful.
+    */
     createFolder(resource: URI): Promise<IFileStatWithMetadata>;
+    /**
+    * Deletes the provided file. The optional useTrash parameter allows to
+    * move the file to trash. The optional recursive parameter allows to delete
+    * non-empty folders recursively.
+    *
+    * Emits a `FileOperation.DELETE` file operation event when successful.
+    */
     del(resource: URI, options?: Partial<IFileDeleteOptions>): Promise<void>;
+    /**
+    * Find out if a delete operation is possible given the arguments. No changes on disk will
+    * be performed. Returns an Error if the operation cannot be done.
+    */
     canDelete(resource: URI, options?: Partial<IFileDeleteOptions>): Promise<Error | true>;
+    /**
+    * An event that signals an error when watching for file changes.
+    */
     readonly onDidWatchError: Event<Error>;
+    /**
+    * Allows to start a watcher that reports file/folder change events on the provided resource.
+    *
+    * The watcher runs correlated and thus, file events will be reported on the returned
+    * `IFileSystemWatcher` and not on the generic `IFileService.onDidFilesChange` event.
+    *
+    * Note: only non-recursive file watching supports event correlation for now.
+    */
     createWatcher(resource: URI, options: IWatchOptionsWithoutCorrelation & {
         recursive: false;
     }): IFileSystemWatcher;
+    /**
+    * Allows to start a watcher that reports file/folder change events on the provided resource.
+    *
+    * The watcher runs uncorrelated and thus will report all events from `IFileService.onDidFilesChange`.
+    * This means, most listeners in the application will receive your events. It is encouraged to
+    * use correlated watchers (via `IWatchOptionsWithCorrelation`) to limit events to your listener.
+    */
     watch(resource: URI, options?: IWatchOptionsWithoutCorrelation): IDisposable;
+    /**
+    * Frees up any resources occupied by this service.
+    */
     dispose(): void;
 }

package/vscode/src/vs/platform/files/common/watcher.d.ts

@@ -3,11 +3,37 @@ import { IRelativePattern, ParsedPattern } from "../../../base/common/glob.js";
 import { Disposable, DisposableStore, IDisposable } from "../../../base/common/lifecycle.js";
 import { FileChangeFilter, IFileChange } from "./files.js";
 interface IWatchRequest {
+    /**
+     * The path to watch.
+     */
     readonly path: string;
+    /**
+     * Whether to watch recursively or not.
+     */
     readonly recursive: boolean;
+    /**
+     * A set of glob patterns or paths to exclude from watching.
+     */
     readonly excludes: string[];
+    /**
+     * An optional set of glob patterns or paths to include for
+     * watching. If not provided, all paths are considered for
+     * events.
+     */
     readonly includes?: Array<string | IRelativePattern>;
+    /**
+     * If provided, file change events from the watcher that
+     * are a result of this watch request will carry the same
+     * id.
+     */
     readonly correlationId?: number;
+    /**
+     * If provided, allows to filter the events that the watcher should consider
+     * for emitting. If not provided, all events are emitted.
+     *
+     * For example, to emit added and updated events, set to:
+     * `FileChangeFilter.ADDED | FileChangeFilter.UPDATED`.
+     */
     readonly filter?: FileChangeFilter;
 }
 export interface IWatchRequestWithCorrelation extends IWatchRequest {
@@ -15,10 +41,20 @@ export interface IWatchRequestWithCorrelation extends IWatchRequest {
 }
 export declare function isWatchRequestWithCorrelation(request: IWatchRequest): request is IWatchRequestWithCorrelation;
 export interface INonRecursiveWatchRequest extends IWatchRequest {
+    /**
+     * The watcher will be non-recursive.
+     */
     readonly recursive: false;
 }
 export interface IRecursiveWatchRequest extends IWatchRequest {
+    /**
+     * The watcher will be recursive.
+     */
     readonly recursive: true;
+    /**
+     * @deprecated this only exists for WSL1 support and should never
+     * be used in any other case.
+     */
     pollingInterval?: number;
 }
 export declare function isRecursiveWatchRequest(request: IWatchRequest): request is IRecursiveWatchRequest;
@@ -28,21 +64,68 @@ export interface IWatcherErrorEvent {
     readonly request?: IUniversalWatchRequest;
 }
 export interface IWatcher {
+    /**
+     * A normalized file change event from the raw events
+     * the watcher emits.
+     */
     readonly onDidChangeFile: Event<IFileChange[]>;
+    /**
+     * An event to indicate a message that should get logged.
+     */
     readonly onDidLogMessage: Event<ILogMessage>;
+    /**
+     * An event to indicate an error occurred from the watcher
+     * that is unrecoverable. Listeners should restart the
+     * watcher if possible.
+     */
     readonly onDidError: Event<IWatcherErrorEvent>;
+    /**
+     * Configures the watcher to watch according to the
+     * requests. Any existing watched path that is not
+     * in the array, will be removed from watching and
+     * any new path will be added to watching.
+     */
     watch(requests: IWatchRequest[]): Promise<void>;
+    /**
+     * Enable verbose logging in the watcher.
+     */
     setVerboseLogging(enabled: boolean): Promise<void>;
+    /**
+     * Stop all watchers.
+     */
     stop(): Promise<void>;
 }
 export interface IRecursiveWatcher extends IWatcher {
     watch(requests: IRecursiveWatchRequest[]): Promise<void>;
 }
 export interface IRecursiveWatcherWithSubscribe extends IRecursiveWatcher {
+    /**
+     * Subscribe to file events for the given path. The callback is called
+     * whenever a file event occurs for the path. If the watcher failed,
+     * the error parameter is set to `true`.
+     *
+     * @returns an `IDisposable` to stop listening to events or `undefined`
+     * if no events can be watched for the path given the current set of
+     * recursive watch requests.
+     */
     subscribe(path: string, callback: (error: true | null, change?: IFileChange) => void): IDisposable | undefined;
 }
 export interface IRecursiveWatcherOptions {
+    /**
+     * If `true`, will enable polling for all watchers, otherwise
+     * will enable it for paths included in the string array.
+     *
+     * @deprecated this only exists for WSL1 support and should never
+     * be used in any other case.
+     */
     readonly usePolling: boolean | string[];
+    /**
+     * If polling is enabled (via `usePolling`), defines the duration
+     * in which the watcher will poll for changes.
+     *
+     * @deprecated this only exists for WSL1 support and should never
+     * be used in any other case.
+     */
     readonly pollingInterval?: number;
 }
 export interface INonRecursiveWatcher extends IWatcher {

package/vscode/src/vs/platform/imageResize/common/imageResizeService.service.d.ts

@@ -1,5 +1,8 @@
 export declare const IImageResizeService: import("../../instantiation/common/instantiation.js").ServiceIdentifier<IImageResizeService>;
 export interface IImageResizeService {
     readonly _serviceBrand: undefined;
+    /**
+    * Resizes an image to a maximum dimension of 768px while maintaining aspect ratio.
+    */
     resizeImage(data: Uint8Array | string, mimeType?: string): Promise<Uint8Array>;
 }

package/vscode/src/vs/platform/instantiation/common/extensions.d.ts

@@ -4,7 +4,15 @@ import './vscode-dts/vscode.d.ts'
 import { SyncDescriptor } from "./descriptors.js";
 import { BrandedService, ServiceIdentifier } from "./instantiation.js";
 export declare enum InstantiationType {
+    /**
+     * Instantiate this service as soon as a consumer depends on it. _Note_ that this
+     * is more costly as some upfront work is done that is likely not needed
+     */
     Eager = 0,
+    /**
+     * Instantiate this service as soon as a consumer uses it. This is the _better_
+     * way of registering a service.
+     */
     Delayed = 1
 }
 export declare function registerSingleton<T, Services extends BrandedService[]>(id: ServiceIdentifier<T>, ctor: new (...services: Services) => T, supportsDelayedInstantiation: InstantiationType): void;

package/vscode/src/vs/platform/instantiation/common/graph.d.ts

@@ -16,6 +16,10 @@ export declare class Graph<T> {
     lookup(data: T): Node<T> | undefined;
     isEmpty(): boolean;
     toString(): string;
+    /**
+     * This is brute force and slow and **only** be used
+     * to trouble shoot.
+     */
     findCycleSlow(): string | undefined;
     private _findCycle;
 }

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

@@ -24,6 +24,10 @@ export interface ServicesAccessor {
     get<T>(id: ServiceIdentifier<T>): T;
 }
 export declare const IInstantiationService: ServiceIdentifier<IInstantiationService>;
+/**
+ * Given a list of arguments as a tuple, attempt to extract the leading, non-service arguments
+ * to their own tuple.
+ */
 export type GetLeadingNonServiceArgs<TArgs extends any[]> = TArgs extends [
 ] ? [
 ] : TArgs extends [
@@ -32,16 +36,43 @@ export type GetLeadingNonServiceArgs<TArgs extends any[]> = TArgs extends [
 ] ? GetLeadingNonServiceArgs<TFirst> : TArgs;
 export interface IInstantiationService {
     readonly _serviceBrand: undefined;
+    /**
+     * Synchronously creates an instance that is denoted by the descriptor
+     */
     createInstance<T>(descriptor: descriptors.SyncDescriptor0<T>): T;
     createInstance<Ctor extends new (...args: any[]) => unknown, R extends InstanceType<Ctor>>(ctor: Ctor, ...args: GetLeadingNonServiceArgs<ConstructorParameters<Ctor>>): R;
+    /**
+     * Calls a function with a service accessor.
+     */
     invokeFunction<R, TS extends any[] = [
     ]>(fn: (accessor: ServicesAccessor, ...args: TS) => R, ...args: TS): R;
+    /**
+     * Creates a child of this service which inherits all current services
+     * and adds/overwrites the given services.
+     *
+     * NOTE that the returned child is `disposable` and should be disposed when not used
+     * anymore. This will also dispose all the services that this service has created.
+     */
     createChild(services: ServiceCollection, store?: DisposableStore): IInstantiationService;
+    /**
+     * Disposes this instantiation service.
+     *
+     * - Will dispose all services that this instantiation service has created.
+     * - Will dispose all its children but not its parent.
+     * - Will NOT dispose services-instances that this service has been created with
+     * - Will NOT dispose consumer-instances this service has created
+     */
     dispose(): void;
 }
+/**
+ * Identifies a service of type `T`.
+ */
 export interface ServiceIdentifier<T> {
     (...args: any[]): void;
     type: T;
 }
+/**
+ * The *only* valid way to create a {{ServiceIdentifier}}.
+ */
 export declare function createDecorator<T>(serviceId: string): ServiceIdentifier<T>;
 export declare function refineServiceDecorator<T1, T extends T1>(serviceIdentifier: ServiceIdentifier<T1>): ServiceIdentifier<T>;

package/vscode/src/vs/platform/jsonschemas/common/jsonContributionRegistry.d.ts

@@ -12,13 +12,31 @@ export interface ISchemaContributions {
 export interface IJSONContributionRegistry {
     readonly onDidChangeSchema: Event<string>;
     readonly onDidChangeSchemaAssociations: Event<void>;
+    /**
+     * Register a schema to the registry.
+     */
     registerSchema(uri: string, unresolvedSchemaContent: IJSONSchema, store?: DisposableStore): void;
     registerSchemaAssociation(uri: string, glob: string): IDisposable;
+    /**
+     * Notifies all listeners that the content of the given schema has changed.
+     * @param uri The id of the schema
+     */
     notifySchemaChanged(uri: string): void;
+    /**
+     * Get all schemas
+     */
     getSchemaContributions(): ISchemaContributions;
     getSchemaAssociations(): {
         [uri: string]: string[];
     };
+    /**
+     * Gets the (compressed) content of the schema with the given schema ID (if any)
+     * @param uri The id of the schema
+     */
     getSchemaContent(uri: string): string | undefined;
+    /**
+     * Returns true if there's a schema that matches the given schema ID
+     * @param uri The id of the schema
+     */
     hasSchemaContent(uri: string): boolean;
 }

package/vscode/src/vs/platform/keybinding/common/abstractKeybindingService.d.ts

@@ -20,6 +20,13 @@ export declare abstract class AbstractKeybindingService extends Disposable imple
     _serviceBrand: undefined;
     protected readonly _onDidUpdateKeybindings: Emitter<void>;
     get onDidUpdateKeybindings(): Event<void>;
+    /** recently recorded keypresses that can trigger a keybinding;
+     *
+     * example: say, there's "cmd+k cmd+i" keybinding;
+     * the user pressed "cmd+k" (before they press "cmd+i")
+     * "cmd+k" would be stored in this array, when on pressing "cmd+i", the service
+     * would invoke the command bound by the keybinding
+     */
     private _currentChords;
     private _currentChordChecker;
     private _currentChordStatusMessage;

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

@@ -12,19 +12,46 @@ export interface IKeybindingService {
     readonly inChordMode: boolean;
     registerContainer(container: HTMLElement): IDisposable;
     onDidUpdateKeybindings: Event<void>;
+    /**
+    * Returns none, one or many (depending on keyboard layout)!
+    */
     resolveKeybinding(keybinding: Keybinding): ResolvedKeybinding[];
     resolveKeyboardEvent(keyboardEvent: IKeyboardEvent): ResolvedKeybinding;
     resolveUserBinding(userBinding: string): ResolvedKeybinding[];
+    /**
+    * Resolve and dispatch `keyboardEvent` and invoke the command.
+    */
     dispatchEvent(e: IKeyboardEvent, target: IContextKeyServiceTarget): boolean;
+    /**
+    * Resolve and dispatch `keyboardEvent`, but do not invoke the command or change inner state.
+    */
     softDispatch(keyboardEvent: IKeyboardEvent, target: IContextKeyServiceTarget): ResolutionResult;
+    /**
+    * Enable hold mode for this command. This is only possible if the command is current being dispatched, meaning
+    * we are after its keydown and before is keyup event.
+    *
+    * @returns A promise that resolves when hold stops, returns undefined if hold mode could not be enabled.
+    */
     enableKeybindingHoldMode(commandId: string): Promise<void> | undefined;
     dispatchByUserSettingsLabel(userSettingsLabel: string, target: IContextKeyServiceTarget): void;
+    /**
+    * Look up keybindings for a command.
+    * Use `lookupKeybinding` if you are interested in the preferred keybinding.
+    */
     lookupKeybindings(commandId: string): ResolvedKeybinding[];
+    /**
+    * Look up the preferred (last defined) keybinding for a command.
+    * @returns The preferred keybinding or null if the command is not bound.
+    */
     lookupKeybinding(commandId: string, context?: IContextKeyService, enforceContextCheck?: boolean): ResolvedKeybinding | undefined;
     getDefaultKeybindingsContent(): string;
     getDefaultKeybindings(): readonly ResolvedKeybindingItem[];
     getKeybindings(): readonly ResolvedKeybindingItem[];
     customKeybindingsCount(): number;
+    /**
+    * Will the given key event produce a character that's rendered on screen, e.g. in a
+    * text box. *Note* that the results of this function can be incorrect.
+    */
     mightProducePrintableCharacter(event: IKeyboardEvent): boolean;
     registerSchemaContribution(contribution: KeybindingsSchemaContribution): IDisposable;
     toggleLogging(): boolean;

package/vscode/src/vs/platform/keybinding/common/keybindingResolver.d.ts

@@ -2,8 +2,11 @@ import { ContextKeyExpression, IContext } from "../../contextkey/common/contextk
 import { IContextKeyService } from "../../contextkey/common/contextkey.service.js";
 import { ResolvedKeybindingItem } from "./resolvedKeybindingItem.js";
 export declare enum ResultKind {
+    /** No keybinding found this sequence of chords */
     NoMatchingKb = 0,
+    /** There're several keybindings that have the given sequence of chords as a prefix */
     MoreChordsNeeded = 1,
+    /** A single keybinding found to be dispatched/invoked */
     KbFound = 2
 }
 export type ResolutionResult = {
@@ -17,6 +20,10 @@ export type ResolutionResult = {
     isBubble: boolean;
 };
 export declare const NoMatchingKb: ResolutionResult;
+/**
+ * Stores mappings from keybindings to commands and from commands to keybindings.
+ * Given a sequence of chords, `resolve`s which keybinding it matches
+ */
 export declare class KeybindingResolver {
     private readonly _log;
     private readonly _defaultKeybindings;
@@ -24,18 +31,34 @@ export declare class KeybindingResolver {
     private readonly _defaultBoundCommands;
     private readonly _map;
     private readonly _lookupMap;
-    constructor(defaultKeybindings: ResolvedKeybindingItem[], overrides: ResolvedKeybindingItem[], log: (str: string) => void);
+    constructor(
+    /** built-in and extension-provided keybindings */
+    defaultKeybindings: ResolvedKeybindingItem[], 
+    /** user's keybindings */
+    overrides: ResolvedKeybindingItem[], log: (str: string) => void);
     private static _isTargetedForRemoval;
+    /**
+     * Looks for rules containing "-commandId" and removes them.
+     */
     static handleRemovals(rules: ResolvedKeybindingItem[]): ResolvedKeybindingItem[];
     private _addKeyPress;
     private _addToLookupMap;
     private _removeFromLookupMap;
+    /**
+     * Returns true if it is provable `a` implies `b`.
+     */
     static whenIsEntirelyIncluded(a: ContextKeyExpression | null | undefined, b: ContextKeyExpression | null | undefined): boolean;
     getDefaultBoundCommands(): Map<string, boolean>;
     getDefaultKeybindings(): readonly ResolvedKeybindingItem[];
     getKeybindings(): readonly ResolvedKeybindingItem[];
     lookupKeybindings(commandId: string): ResolvedKeybindingItem[];
     lookupPrimaryKeybinding(commandId: string, context: IContextKeyService, enforceContextCheck?: boolean): ResolvedKeybindingItem | null;
+    /**
+     * Looks up a keybinding trigged as a result of pressing a sequence of chords - `[...currentChords, keypress]`
+     *
+     * Example: resolving 3 chords pressed sequentially - `cmd+k cmd+p cmd+i`:
+     * 	`currentChords = [ 'cmd+k' , 'cmd+p' ]` and `keypress = `cmd+i` - last pressed chord
+     */
     resolve(context: IContext, currentChords: string[], keypress: string): ResolutionResult;
     private _findCommand;
     private static _contextMatchesRules;

package/vscode/src/vs/platform/keybinding/common/keybindingsRegistry.d.ts

@@ -32,6 +32,9 @@ export interface IKeybindingRule extends IKeybindings {
     id: string;
     weight: number;
     args?: any;
+    /**
+     * Keybinding is disabled if expression returns false.
+     */
     when?: ContextKeyExpression | null | undefined;
 }
 export interface IExtensionKeybindingRule {

package/vscode/src/vs/platform/keybinding/common/usLayoutResolvedKeybinding.d.ts

@@ -1,6 +1,9 @@
 import { SingleModifierChord, KeyCodeChord, Keybinding } from "../../../base/common/keybindings.js";
 import { OperatingSystem } from "../../../base/common/platform.js";
 import { BaseResolvedKeybinding } from "./baseResolvedKeybinding.js";
+/**
+ * Do not instantiate. Use KeybindingService to get a ResolvedKeybinding seeded with information about the current kb layout.
+ */
 export declare class USLayoutResolvedKeybinding extends BaseResolvedKeybinding<KeyCodeChord> {
     constructor(chords: KeyCodeChord[], os: OperatingSystem);
     private _keyCodeToUILabel;
@@ -12,6 +15,9 @@ export declare class USLayoutResolvedKeybinding extends BaseResolvedKeybinding<K
     protected _getChordDispatch(chord: KeyCodeChord): string | null;
     static getDispatchStr(chord: KeyCodeChord): string | null;
     protected _getSingleModifierChordDispatch(keybinding: KeyCodeChord): SingleModifierChord | null;
+    /**
+     * *NOTE*: Check return value for `KeyCode.Unknown`.
+     */
     private static _scanCodeToKeyCode;
     private static _toKeyCodeChord;
     static resolveKeybinding(keybinding: Keybinding, os: OperatingSystem): USLayoutResolvedKeybinding[];

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

@@ -6,6 +6,13 @@ import { Verbosity, ResourceLabelFormatter, IFormatterChangeEvent } from "@codin
 export declare const ILabelService: import("../../instantiation/common/instantiation.js").ServiceIdentifier<ILabelService>;
 export interface ILabelService {
     readonly _serviceBrand: undefined;
+    /**
+    * Gets the human readable label for a uri.
+    * If `relative` is passed returns a label relative to the workspace root that the uri belongs to.
+    * If `noPrefix` is passed does not tildify the label and also does not prepand the root name for relative labels in a multi root scenario.
+    * If `separator` is passed, will use that over the defined path separator of the formatter.
+    * If `appendWorkspaceSuffix` is passed, will append the name of the workspace to the label.
+    */
     getUriLabel(resource: URI, options?: {
         relative?: boolean;
         noPrefix?: boolean;
@@ -21,5 +28,10 @@ export interface ILabelService {
     getSeparator(scheme: string, authority?: string): "/" | "\\";
     registerFormatter(formatter: ResourceLabelFormatter): IDisposable;
     onDidChangeFormatters: Event<IFormatterChangeEvent>;
+    /**
+    * Registers a formatter that's cached for the machine beyond the lifecycle
+    * of the current window. Disposing the formatter _will not_ remove it from
+    * the cache.
+    */
     registerCachedFormatter(formatter: ResourceLabelFormatter): IDisposable;
 }

package/vscode/src/vs/platform/layout/browser/layoutService.d.ts

@@ -1,4 +1,10 @@
 export interface ILayoutOffsetInfo {
+    /**
+     * Generic top offset
+     */
     readonly top: number;
+    /**
+     * Quick pick specific top offset.
+     */
     readonly quickPickTop: number;
 }