@codingame/monaco-vscode-api 20.1.1 → 20.2.0

package/vscode/src/vs/workbench/services/textfile/common/textfiles.d.ts

@@ -10,15 +10,36 @@ import { IWorkingCopy, IWorkingCopySaveEvent } from "@codingame/monaco-vscode-ca
 import { CancellationToken } from "../../../../base/common/cancellation.js";
 import { IProgress, IProgressStep } from "../../../../platform/progress/common/progress.js";
 export interface IReadTextFileEncodingOptions {
+    /**
+     * The optional encoding parameter allows to specify the desired encoding when resolving
+     * the contents of the file.
+     */
     readonly encoding?: string;
+    /**
+     * The optional guessEncoding parameter allows to guess encoding from content of the file.
+     */
     readonly autoGuessEncoding?: boolean;
+    /**
+     * The optional candidateGuessEncodings parameter limits the allowed encodings to guess from.
+     */
     readonly candidateGuessEncodings?: string[];
+    /**
+     * The optional acceptTextOnly parameter allows to fail this request early if the file
+     * contents are not textual.
+     */
     readonly acceptTextOnly?: boolean;
 }
 export interface IReadTextFileOptions extends IReadTextFileEncodingOptions, IReadFileStreamOptions {
 }
 export interface IWriteTextFileOptions extends IWriteFileOptions {
+    /**
+     * The encoding to use when updating a file.
+     */
     readonly encoding?: string;
+    /**
+     * Whether to write to the file as elevated (admin) user. When setting this option a prompt will
+     * ask the user to authenticate as super user.
+     */
     readonly writeElevated?: boolean;
 }
 export declare enum TextFileOperationResult {
@@ -38,15 +59,44 @@ export interface IResourceEncoding {
     readonly encoding: string;
     readonly hasBOM: boolean;
 }
+/**
+ * The save error handler can be installed on the text file editor model to install code that executes when save errors occur.
+ */
 export interface ISaveErrorHandler {
+    /**
+     * Called whenever a save fails.
+     */
     onSaveError(error: Error, model: ITextFileEditorModel, options: ITextFileSaveAsOptions): void;
 }
+/**
+ * States the text file editor model can be in.
+ */
 export declare enum TextFileEditorModelState {
+    /**
+     * A model is saved.
+     */
     SAVED = 0,
+    /**
+     * A model is dirty.
+     */
     DIRTY = 1,
+    /**
+     * A model is currently being saved but this operation has not completed yet.
+     */
     PENDING_SAVE = 2,
+    /**
+     * A model is in conflict mode when changes cannot be saved because the
+     * underlying file has changed. Models in conflict mode are always dirty.
+     */
     CONFLICT = 3,
+    /**
+     * A model is in orphan state when the underlying file has been deleted.
+     */
     ORPHAN = 4,
+    /**
+     * Any error that happens during a save that is not causing the CONFLICT state.
+     * Models in error mode are always dirty.
+     */
     ERROR = 5
 }
 export declare enum TextFileResolveReason {
@@ -55,34 +105,83 @@ export declare enum TextFileResolveReason {
     OTHER = 3
 }
 interface IBaseTextFileContent extends IBaseFileStatWithMetadata {
+    /**
+     * The encoding of the content if known.
+     */
     readonly encoding: string;
 }
 export interface ITextFileContent extends IBaseTextFileContent {
+    /**
+     * The content of a text file.
+     */
     readonly value: string;
 }
 export interface ITextFileStreamContent extends IBaseTextFileContent {
+    /**
+     * The line grouped content of a text file.
+     */
     readonly value: ITextBufferFactory;
 }
 export interface ITextFileEditorModelResolveOrCreateOptions extends ITextFileResolveOptions {
+    /**
+     * The language id to use for the model text content.
+     */
     readonly languageId?: string;
+    /**
+     * The encoding to use when resolving the model text content.
+     */
     readonly encoding?: string;
+    /**
+     * If the model was already resolved before, allows to trigger
+     * a reload of it to fetch the latest contents.
+     */
     readonly reload?: {
+        /**
+         * Controls whether the reload happens in the background
+         * or whether `resolve` will await the reload to happen.
+         */
         readonly async: boolean;
     };
 }
 export interface ITextFileSaveEvent extends ITextFileEditorModelSaveEvent {
+    /**
+     * The model that was saved.
+     */
     readonly model: ITextFileEditorModel;
 }
 export interface ITextFileResolveEvent {
+    /**
+     * The model that was resolved.
+     */
     readonly model: ITextFileEditorModel;
+    /**
+     * The reason why the model was resolved.
+     */
     readonly reason: TextFileResolveReason;
 }
 export interface ITextFileSaveParticipantContext {
+    /**
+     * The reason why the save was triggered.
+     */
     readonly reason: SaveReason;
+    /**
+     * Only applies to when a text file was saved as, for
+     * example when starting with untitled and saving. This
+     * provides access to the initial resource the text
+     * file had before.
+     */
     readonly savedFrom?: URI;
 }
 export interface ITextFileSaveParticipant {
+    /**
+     * The ordinal number which determines the order of participation.
+     * Lower values mean to participant sooner
+     */
     readonly ordinal?: number;
+    /**
+     * Participate in a save of a model. Allows to change the model
+     * before it is being saved to disk.
+     */
     participate(model: ITextFileEditorModel, context: ITextFileSaveParticipantContext, progress: IProgress<IProgressStep>, token: CancellationToken): Promise<void>;
 }
 export interface ITextFileEditorModelManager {
@@ -96,43 +195,123 @@ export interface ITextFileEditorModelManager {
     readonly onDidSaveError: Event<ITextFileEditorModel>;
     readonly onDidSave: Event<ITextFileSaveEvent>;
     readonly onDidRevert: Event<ITextFileEditorModel>;
+    /**
+     * Access to all text file editor models in memory.
+     */
     readonly models: ITextFileEditorModel[];
+    /**
+     * Allows to configure the error handler that is called on save errors.
+     */
     saveErrorHandler: ISaveErrorHandler;
+    /**
+     * Returns the text file editor model for the provided resource
+     * or undefined if none.
+     */
     get(resource: URI): ITextFileEditorModel | undefined;
+    /**
+     * Allows to resolve a text file model from disk.
+     */
     resolve(resource: URI, options?: ITextFileEditorModelResolveOrCreateOptions): Promise<ITextFileEditorModel>;
+    /**
+     * Adds a participant for saving text file models.
+     */
     addSaveParticipant(participant: ITextFileSaveParticipant): IDisposable;
+    /**
+     * Runs the registered save participants on the provided model.
+     */
     runSaveParticipants(model: ITextFileEditorModel, context: ITextFileSaveParticipantContext, progress: IProgress<IProgressStep>, token: CancellationToken): Promise<void>;
+    /**
+     * Waits for the model to be ready to be disposed. There may be conditions
+     * under which the model cannot be disposed, e.g. when it is dirty. Once the
+     * promise is settled, it is safe to dispose the model.
+     */
     canDispose(model: ITextFileEditorModel): true | Promise<true>;
 }
 export interface ITextFileSaveOptions extends ISaveOptions {
+    /**
+     * Save the file with an attempt to unlock it.
+     */
     readonly writeUnlock?: boolean;
+    /**
+     * Save the file with elevated privileges.
+     *
+     * Note: This may not be supported in all environments.
+     */
     readonly writeElevated?: boolean;
+    /**
+     * Allows to write to a file even if it has been modified on disk.
+     */
     readonly ignoreModifiedSince?: boolean;
+    /**
+     * If set, will bubble up the error to the caller instead of handling it.
+     */
     readonly ignoreErrorHandler?: boolean;
 }
 export interface ITextFileSaveAsOptions extends ITextFileSaveOptions {
+    /**
+     * Optional URI of the resource the text file is saved from if known.
+     */
     readonly from?: URI;
+    /**
+     * Optional URI to use as suggested file path to save as.
+     */
     readonly suggestedTarget?: URI;
 }
 export interface ITextFileResolveOptions {
+    /**
+     * The contents to use for the model if known. If not
+     * provided, the contents will be retrieved from the
+     * underlying resource or backup if present.
+     */
     readonly contents?: ITextBufferFactory;
+    /**
+     * Go to file bypassing any cache of the model if any.
+     */
     readonly forceReadFromFile?: boolean;
+    /**
+     * Allow to resolve a model even if we think it is a binary file.
+     */
     readonly allowBinary?: boolean;
+    /**
+     * Context why the model is being resolved.
+     */
     readonly reason?: TextFileResolveReason;
+    /**
+     * If provided, the size of the file will be checked against the limits
+     * and an error will be thrown if any limit is exceeded.
+     */
     readonly limits?: IFileReadLimits;
 }
 export declare enum EncodingMode {
+    /**
+     * Instructs the encoding support to encode the object with the provided encoding
+     */
     Encode = 0,
+    /**
+     * Instructs the encoding support to decode the object with the provided encoding
+     */
     Decode = 1
 }
 export interface IEncodingSupport {
+    /**
+     * Gets the encoding of the object if known.
+     */
     getEncoding(): string | undefined;
+    /**
+     * Sets the encoding for the object for saving.
+     */
     setEncoding(encoding: string, mode: EncodingMode): Promise<void>;
 }
 export interface ILanguageSupport {
+    /**
+     * Sets the language id of the object.
+     */
     setLanguageId(languageId: string, source?: string): void;
 }
 export interface ITextFileEditorModelSaveEvent extends IWorkingCopySaveEvent {
+    /**
+     * The resolved stat from the save operation.
+     */
     readonly stat: IFileStatWithMetadata;
 }
 export interface ITextFileEditorModel extends ITextEditorModel, IEncodingSupport, ILanguageSupport, IWorkingCopy {

package/vscode/src/vs/workbench/services/textfile/common/textfiles.service.d.ts

@@ -11,16 +11,66 @@ import { ITextFileEditorModelManager, IResourceEncodings, ITextFileSaveOptions,
 export declare const ITextFileService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<ITextFileService>;
 export interface ITextFileService extends IDisposable {
     readonly _serviceBrand: undefined;
+    /**
+    * Access to the manager of text file editor models providing further
+    * methods to work with them.
+    */
     readonly files: ITextFileEditorModelManager;
+    /**
+    * Access to the manager of untitled text editor models providing further
+    * methods to work with them.
+    */
     readonly untitled: IUntitledTextEditorModelManager;
+    /**
+    * Helper to determine encoding for resources.
+    */
     readonly encoding: IResourceEncodings;
+    /**
+    * A resource is dirty if it has unsaved changes or is an untitled file not yet saved.
+    *
+    * @param resource the resource to check for being dirty
+    */
     isDirty(resource: URI): boolean;
+    /**
+    * Saves the resource.
+    *
+    * @param resource the resource to save
+    * @param options optional save options
+    * @return Path of the saved resource or undefined if canceled.
+    */
     save(resource: URI, options?: ITextFileSaveOptions): Promise<URI | undefined>;
+    /**
+    * Saves the provided resource asking the user for a file name or using the provided one.
+    *
+    * @param resource the resource to save as.
+    * @param targetResource the optional target to save to.
+    * @param options optional save options
+    * @return Path of the saved resource or undefined if canceled.
+    */
     saveAs(resource: URI, targetResource?: URI, options?: ITextFileSaveAsOptions): Promise<URI | undefined>;
+    /**
+    * Reverts the provided resource.
+    *
+    * @param resource the resource of the file to revert.
+    * @param force to force revert even when the file is not dirty
+    */
     revert(resource: URI, options?: IRevertOptions): Promise<void>;
+    /**
+    * Read the contents of a file identified by the resource.
+    */
     read(resource: URI, options?: IReadTextFileOptions): Promise<ITextFileContent>;
+    /**
+    * Read the contents of a file identified by the resource as stream.
+    */
     readStream(resource: URI, options?: IReadTextFileOptions): Promise<ITextFileStreamContent>;
+    /**
+    * Update a file with given contents.
+    */
     write(resource: URI, value: string | ITextSnapshot, options?: IWriteTextFileOptions): Promise<IFileStatWithMetadata>;
+    /**
+    * Create files. If the file exists it will be overwritten with the contents if
+    * the options enable to overwrite.
+    */
     create(operations: {
         resource: URI;
         value?: string | ITextSnapshot;
@@ -28,21 +78,45 @@ export interface ITextFileService extends IDisposable {
             overwrite?: boolean;
         };
     }[], undoInfo?: IFileOperationUndoRedoInfo): Promise<readonly IFileStatWithMetadata[]>;
+    /**
+    * Returns the readable that uses the appropriate encoding. This method should
+    * be used whenever a `string` or `ITextSnapshot` is being persisted to the
+    * file system.
+    */
     getEncodedReadable(resource: URI | undefined, value: ITextSnapshot, options?: IWriteTextFileOptions): Promise<VSBufferReadable>;
     getEncodedReadable(resource: URI | undefined, value: string, options?: IWriteTextFileOptions): Promise<VSBuffer | VSBufferReadable>;
     getEncodedReadable(resource: URI | undefined, value?: ITextSnapshot, options?: IWriteTextFileOptions): Promise<VSBufferReadable | undefined>;
     getEncodedReadable(resource: URI | undefined, value?: string, options?: IWriteTextFileOptions): Promise<VSBuffer | VSBufferReadable | undefined>;
     getEncodedReadable(resource: URI | undefined, value?: string | ITextSnapshot, options?: IWriteTextFileOptions): Promise<VSBuffer | VSBufferReadable | undefined>;
+    /**
+    * Returns a stream of strings that uses the appropriate encoding. This method should
+    * be used whenever a `VSBufferReadableStream` is being loaded from the file system.
+    *
+    * Will throw an error if `acceptTextOnly: true` for resources that seem to be binary.
+    */
     getDecodedStream(resource: URI | undefined, value: VSBufferReadableStream, options?: IReadTextFileEncodingOptions): Promise<ReadableStream<string>>;
+    /**
+    * Get the encoding for the provided `resource`. Will try to determine the encoding
+    * from any existing model for that `resource` and fallback to the configured defaults.
+    */
     getEncoding(resource: URI): string;
+    /**
+    * Get the properties for decoding the provided `resource` based on configuration.
+    */
     resolveDecoding(resource: URI | undefined, options?: IReadTextFileEncodingOptions): Promise<{
         preferredEncoding: string;
         guessEncoding: boolean;
         candidateGuessEncodings: string[];
     }>;
+    /**
+    * Get the properties for encoding the provided `resource` based on configuration.
+    */
     resolveEncoding(resource: URI | undefined, options?: IWriteTextFileOptions): Promise<{
         encoding: string;
         addBOM: boolean;
     }>;
+    /**
+    * Given a detected encoding, validate it against the configured encoding options.
+    */
     validateDetectedEncoding(resource: URI | undefined, detectedEncoding: string, options?: IReadTextFileEncodingOptions): Promise<string>;
 }

package/vscode/src/vs/workbench/services/timer/browser/timerService.service.d.ts

@@ -2,15 +2,46 @@ import * as perf from "../../../../base/common/performance.js";
 import { IStartupMetrics } from "@codingame/monaco-vscode-lifecycle-service-override/vscode/vs/workbench/services/timer/browser/timerService";
 export interface ITimerService {
     readonly _serviceBrand: undefined;
+    /**
+    * A promise that resolved when startup timings and perf marks
+    * are available. This depends on lifecycle phases and extension
+    * hosts being started.
+    */
     whenReady(): Promise<boolean>;
+    /**
+    * A baseline performance indicator for this machine. The value will only available
+    * late after startup because computing it takes away CPU resources
+    *
+    * NOTE that this returns -1 if the machine is hopelessly slow...
+    */
     perfBaseline: Promise<number>;
+    /**
+    * Startup metrics. Can ONLY be accessed after `whenReady` has resolved.
+    */
     readonly startupMetrics: IStartupMetrics;
+    /**
+    * Deliver performance marks from a source, like the main process or extension hosts.
+    * The source argument acts as an identifier and therefore it must be unique.
+    */
     setPerformanceMarks(source: string, marks: perf.PerformanceMark[]): void;
+    /**
+    * Get all currently known performance marks by source. There is no sorting of the
+    * returned tuples but the marks of a tuple are guaranteed to be sorted by start times.
+    */
     getPerformanceMarks(): [
         source: string,
         marks: readonly perf.PerformanceMark[]
     ][];
+    /**
+    * Return the duration between two marks.
+    * @param from from mark name
+    * @param to to mark name
+    */
     getDuration(from: string, to: string): number;
+    /**
+    * Return the timestamp of a mark.
+    * @param mark mark name
+    */
     getStartTime(mark: string): number;
 }
 export declare const ITimerService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<ITimerService>;

package/vscode/src/vs/workbench/services/title/browser/titleService.service.d.ts

@@ -4,6 +4,12 @@ import { IEditorGroupsContainer } from "../../editor/common/editorGroupsService.
 export declare const ITitleService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<ITitleService>;
 export interface ITitleService extends ITitlebarPart {
     readonly _serviceBrand: undefined;
+    /**
+    * Get the status bar part that is rooted in the provided container.
+    */
     getPart(container: HTMLElement): ITitlebarPart;
+    /**
+    * Creates a new auxililary title bar part in the provided container.
+    */
     createAuxiliaryTitlebarPart(container: HTMLElement, editorGroupsContainer: IEditorGroupsContainer, instantiationService: IInstantiationService): IAuxiliaryTitlebarPart;
 }

package/vscode/src/vs/workbench/services/untitled/common/untitledTextEditorService.service.d.ts

@@ -5,20 +5,66 @@ import { IUntitledTextEditorModelSaveEvent, INewUntitledTextEditorOptions, INewU
 export declare const IUntitledTextEditorService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IUntitledTextEditorService>;
 export interface IUntitledTextEditorService {
     readonly _serviceBrand: undefined;
+    /**
+    * An event for when an untitled editor model was saved to disk.
+    * At the point the event fires, the untitled editor model is
+    * disposed.
+    */
     readonly onDidSave: Event<IUntitledTextEditorModelSaveEvent>;
+    /**
+    * Events for when untitled text editors change (e.g. getting dirty, saved or reverted).
+    */
     readonly onDidChangeDirty: Event<IUntitledTextEditorModel>;
+    /**
+    * Events for when untitled text editor encodings change.
+    */
     readonly onDidChangeEncoding: Event<IUntitledTextEditorModel>;
+    /**
+    * Events for when untitled text editor labels change.
+    */
     readonly onDidChangeLabel: Event<IUntitledTextEditorModel>;
+    /**
+    * Events for when untitled text editor models are created.
+    */
     readonly onDidCreate: Event<IUntitledTextEditorModel>;
+    /**
+    * Events for when untitled text editors are about to be disposed.
+    */
     readonly onWillDispose: Event<IUntitledTextEditorModel>;
+    /**
+    * Creates a new untitled editor model with the provided options. If the `untitledResource`
+    * property is provided and the untitled editor exists, it will return that existing
+    * instance instead of creating a new one.
+    */
     create(options?: INewUntitledTextEditorOptions): IUntitledTextEditorModel;
     create(options?: INewUntitledTextEditorWithAssociatedResourceOptions): IUntitledTextEditorModel;
     create(options?: IExistingUntitledTextEditorOptions): IUntitledTextEditorModel;
+    /**
+    * Returns an existing untitled editor model if already created before.
+    */
     get(resource: URI): IUntitledTextEditorModel | undefined;
+    /**
+    * Returns the value of the untitled editor, undefined if none exists
+    * @param resource The URI of the untitled file
+    * @returns The content, or undefined
+    */
     getValue(resource: URI): string | undefined;
+    /**
+    * Resolves an untitled editor model from the provided options. If the `untitledResource`
+    * property is provided and the untitled editor exists, it will return that existing
+    * instance instead of creating a new one.
+    */
     resolve(options?: INewUntitledTextEditorOptions): Promise<IUntitledTextEditorModel>;
     resolve(options?: INewUntitledTextEditorWithAssociatedResourceOptions): Promise<IUntitledTextEditorModel>;
     resolve(options?: IExistingUntitledTextEditorOptions): Promise<IUntitledTextEditorModel>;
+    /**
+    * Figures out if the given resource has an associated resource or not.
+    */
     isUntitledWithAssociatedResource(resource: URI): boolean;
+    /**
+    * Waits for the model to be ready to be disposed. There may be conditions
+    * under which the model cannot be disposed, e.g. when it is dirty. Once the
+    * promise is settled, it is safe to dispose the model.
+    */
     canDispose(model: IUntitledTextEditorModel): true | Promise<true>;
 }

package/vscode/src/vs/workbench/services/userActivity/common/userActivityService.service.d.ts

@@ -2,9 +2,23 @@ import { Event } from "../../../../base/common/event.js";
 import { IDisposable } from "../../../../base/common/lifecycle.js";
 import { IMarkActiveOptions } from "@codingame/monaco-vscode-base-service-override/vscode/vs/workbench/services/userActivity/common/userActivityService";
 export declare const IUserActivityService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IUserActivityService>;
+/**
+* Service that observes user activity in the window.
+*/
 export interface IUserActivityService {
     _serviceBrand: undefined;
+    /**
+    * Whether the user is currently active.
+    */
     readonly isActive: boolean;
+    /**
+    * Fires when the activity state changes.
+    */
     readonly onDidChangeIsActive: Event<boolean>;
+    /**
+    * Marks the user as being active until the Disposable is disposed of.
+    * Multiple consumers call this method; the user will only be considered
+    * inactive once all consumers have disposed of their Disposables.
+    */
     markActive(opts?: IMarkActiveOptions): IDisposable;
 }

package/vscode/src/vs/workbench/services/workingCopy/common/workingCopyBackup.d.ts

@@ -1,6 +1,17 @@
 import { VSBufferReadableStream } from "../../../../base/common/buffer.js";
 import { IWorkingCopyBackupMeta } from "@codingame/monaco-vscode-caeb744c-8e3f-5c11-80fb-0f057d24d544-common/vscode/vs/workbench/services/workingCopy/common/workingCopy";
+/**
+ * A resolved working copy backup carries the backup value
+ * as well as associated metadata with it.
+ */
 export interface IResolvedWorkingCopyBackup<T extends IWorkingCopyBackupMeta> {
+    /**
+     * The content of the working copy backup.
+     */
     readonly value: VSBufferReadableStream;
+    /**
+     * Additional metadata that is associated with
+     * the working copy backup.
+     */
     readonly meta?: T;
 }

package/vscode/src/vs/workbench/services/workingCopy/common/workingCopyBackup.service.d.ts

@@ -3,13 +3,45 @@ import { CancellationToken } from "../../../../base/common/cancellation.js";
 import { IWorkingCopyIdentifier, IWorkingCopyBackupMeta } from "@codingame/monaco-vscode-caeb744c-8e3f-5c11-80fb-0f057d24d544-common/vscode/vs/workbench/services/workingCopy/common/workingCopy";
 import { IResolvedWorkingCopyBackup } from "./workingCopyBackup.js";
 export declare const IWorkingCopyBackupService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IWorkingCopyBackupService>;
+/**
+* The working copy backup service is the main service to handle backups
+* for working copies.
+* Methods allow to persist and resolve working copy backups from the file
+* system.
+*/
 export interface IWorkingCopyBackupService {
     readonly _serviceBrand: undefined;
+    /**
+    * Finds out if a working copy backup with the given identifier
+    * and optional version exists.
+    *
+    * Note: if the backup service has not been initialized yet, this may return
+    * the wrong result. Always use `resolve()` if you can do a long running
+    * operation.
+    */
     hasBackupSync(identifier: IWorkingCopyIdentifier, versionId?: number): boolean;
+    /**
+    * Gets a list of working copy backups for the current workspace.
+    */
     getBackups(): Promise<readonly IWorkingCopyIdentifier[]>;
+    /**
+    * Resolves the working copy backup for the given identifier if that exists.
+    */
     resolve<T extends IWorkingCopyBackupMeta>(identifier: IWorkingCopyIdentifier): Promise<IResolvedWorkingCopyBackup<T> | undefined>;
+    /**
+    * Stores a new working copy backup for the given identifier.
+    */
     backup(identifier: IWorkingCopyIdentifier, content?: VSBufferReadable | VSBufferReadableStream, versionId?: number, meta?: IWorkingCopyBackupMeta, token?: CancellationToken): Promise<void>;
+    /**
+    * Discards the working copy backup associated with the identifier if it exists.
+    */
     discardBackup(identifier: IWorkingCopyIdentifier, token?: CancellationToken): Promise<void>;
+    /**
+    * Discards all working copy backups.
+    *
+    * The optional set of identifiers in the filter can be
+    * provided to discard all but the provided ones.
+    */
     discardBackups(filter?: {
         except: IWorkingCopyIdentifier[];
     }): Promise<void>;

package/vscode/src/vs/workbench/services/workingCopy/common/workingCopyEditorService.service.d.ts

@@ -6,7 +6,16 @@ import { IWorkingCopyEditorHandler } from "@codingame/monaco-vscode-working-copy
 export declare const IWorkingCopyEditorService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IWorkingCopyEditorService>;
 export interface IWorkingCopyEditorService {
     readonly _serviceBrand: undefined;
+    /**
+    * An event fired whenever a handler is registered.
+    */
     readonly onDidRegisterHandler: Event<IWorkingCopyEditorHandler>;
+    /**
+    * Register a handler to the working copy editor service.
+    */
     registerHandler(handler: IWorkingCopyEditorHandler): IDisposable;
+    /**
+    * Finds the first editor that can handle the provided working copy.
+    */
     findEditor(workingCopy: IWorkingCopy): IEditorIdentifier | undefined;
 }