@codingame/monaco-vscode-api 1.79.11 → 1.79.12

package/dist/editor.d.ts

@@ -1,8 +1,9 @@
-import { E as Event, b as Emitter, a as IDisposable, D as Disposable } from './event.js';
+import { E as Event, c as Emitter, C as CancellationToken, a as IDisposable, d as IWaitUntil, D as Disposable } from './event.js';
 import { U as URI } from './uri.js';
-import { k as IMarkdownString, d as IEditorOptions, l as IEditorModel, m as IDimension, j as IComposite, i as IDiffEditor, n as ICompositeControl, o as IBaseTextResourceEditorInput, p as IBaseUntypedEditorInput, e as IResourceEditorInput, f as ITextResourceEditorInput } from './editorBrowser.js';
+import { q as IMarkdownString, d as IEditorOptions, r as IEditorModel, s as IDimension, t as ITextEditorModel, u as IProgress, v as IProgressStep, w as ITextSnapshot, x as ITextBufferFactory, l as ITextModel, j as IComposite, i as IDiffEditor, y as ICompositeControl, z as IBaseTextResourceEditorInput, A as IBaseUntypedEditorInput, e as IResourceEditorInput, f as ITextResourceEditorInput } from './editorBrowser.js';
 import { S as ServiceIdentifier, I as IInstantiationService } from './instantiation.js';
 import { a as IContextKeyService } from './contextkey.js';
+import { V as VSBufferReadable, n as VSBufferReadableStream, o as IFileStatWithMetadata, p as FileOperation, q as VSBuffer, r as ReadableStream, s as IReadFileStreamOptions, t as IWriteFileOptions, u as IBaseFileStatWithMetadata, v as IFileReadLimits } from './files.js';
 import { T as ThemeIcon } from './themables.js';
 import { S as Severity } from './severity.js';
 
@@ -420,6 +421,161 @@ declare abstract class EditorInput extends AbstractEditorInput {
     dispose(): void;
 }
 
+declare const enum WorkingCopyCapabilities {
+    /**
+     * Signals no specific capability for the working copy.
+     */
+    None = 0,
+    /**
+     * Signals that the working copy requires
+     * additional input when saving, e.g. an
+     * associated path to save to.
+     */
+    Untitled = 2,
+    /**
+     * The working copy will not indicate that
+     * it is dirty and unsaved content will be
+     * discarded without prompting if closed.
+     */
+    Scratchpad = 4
+}
+/**
+ * Data to be associated with working copy backups. Use
+ * `IWorkingCopyBackupService.resolve(workingCopy)` to
+ * retrieve the backup when loading the working copy.
+ */
+interface IWorkingCopyBackup {
+    /**
+     * Any serializable metadata to be associated with the backup.
+     */
+    meta?: IWorkingCopyBackupMeta;
+    /**
+     * The actual snapshot of the contents of the working copy at
+     * the time the backup was made.
+     */
+    content?: VSBufferReadable | VSBufferReadableStream;
+}
+/**
+ * Working copy backup metadata that can be associated
+ * with the backup.
+ *
+ * Some properties may be reserved as outlined here and
+ * cannot be used.
+ */
+interface IWorkingCopyBackupMeta {
+    /**
+     * Any property needs to be serializable through JSON.
+     */
+    [key: string]: unknown;
+    /**
+     * `typeId` is a reserved property that cannot be used
+     * as backup metadata.
+     */
+    typeId?: never;
+}
+/**
+ * Every working copy has in common that it is identified by
+ * a resource `URI` and a `typeId`. There can only be one
+ * working copy registered with the same `URI` and `typeId`.
+ */
+interface IWorkingCopyIdentifier {
+    /**
+     * The type identifier of the working copy for grouping
+     * working copies of the same domain together.
+     *
+     * There can only be one working copy for a given resource
+     * and type identifier.
+     */
+    readonly typeId: string;
+    /**
+     * The resource of the working copy must be unique for
+     * working copies of the same `typeId`.
+     */
+    readonly resource: URI;
+}
+interface IWorkingCopySaveEvent {
+    /**
+     * The reason why the working copy was saved.
+     */
+    readonly reason?: SaveReason;
+    /**
+     * The source of the working copy save request.
+     */
+    readonly source?: SaveSource;
+}
+/**
+ * A working copy is an abstract concept to unify handling of
+ * data that can be worked on (e.g. edited) in an editor.
+ *
+ *
+ * A working copy resource may be the backing store of the data
+ * (e.g. a file on disk), but that is not a requirement. If
+ * your working copy is file based, consider to use the
+ * `IFileWorkingCopy` instead that simplifies a lot of things
+ * when working with file based working copies.
+ */
+interface IWorkingCopy extends IWorkingCopyIdentifier {
+    /**
+     * Human readable name of the working copy.
+     */
+    readonly name: string;
+    /**
+     * The capabilities of the working copy.
+     */
+    readonly capabilities: WorkingCopyCapabilities;
+    /**
+     * Used by the workbench to signal if the working copy
+     * is dirty or not. Typically a working copy is dirty
+     * once changed until saved or reverted.
+     */
+    readonly onDidChangeDirty: Event<void>;
+    /**
+     * Used by the workbench e.g. to trigger auto-save
+     * (unless this working copy is untitled) and backups.
+     */
+    readonly onDidChangeContent: Event<void>;
+    /**
+     * Used by the workbench e.g. to track local history
+     * (unless this working copy is untitled).
+     */
+    readonly onDidSave: Event<IWorkingCopySaveEvent>;
+    /**
+     * Indicates that the file has unsaved changes
+     * and should confirm before closing.
+     */
+    isDirty(): boolean;
+    /**
+     * Indicates that the file has unsaved changes.
+     * Used for backup tracking and accounts for
+     * working copies that are never dirty e.g.
+     * scratchpads.
+     */
+    isModified(): boolean;
+    /**
+     * The workbench may call this method often after it receives
+     * the `onDidChangeContent` event for the working copy. The motivation
+     * is to allow to quit VSCode with dirty working copies present.
+     *
+     * Providers of working copies should use `IWorkingCopyBackupService.resolve(workingCopy)`
+     * to retrieve the backup metadata associated when loading the working copy.
+     *
+     * @param token support for cancellation
+     */
+    backup(token: CancellationToken): Promise<IWorkingCopyBackup>;
+    /**
+     * Asks the working copy to save. If the working copy was dirty, it is
+     * expected to be non-dirty after this operation has finished.
+     *
+     * @returns `true` if the operation was successful and `false` otherwise.
+     */
+    save(options?: ISaveOptions): Promise<boolean>;
+    /**
+     * Asks the working copy to revert. If the working copy was dirty, it is
+     * expected to be non-dirty after this operation has finished.
+     */
+    revert(options?: IRevertOptions): Promise<void>;
+}
+
 interface IGroupModelChangeEvent {
     /**
      * The kind of change that occurred in the group model.
@@ -1038,6 +1194,947 @@ interface IEditorGroup {
     focus(): void;
 }
 
+interface IUntitledTextEditorModel extends ITextEditorModel, ILanguageSupport, IEncodingSupport, IWorkingCopy {
+    /**
+     * Emits an event when the encoding of this untitled model changes.
+     */
+    readonly onDidChangeEncoding: Event<void>;
+    /**
+     * Emits an event when the name of this untitled model changes.
+     */
+    readonly onDidChangeName: Event<void>;
+    /**
+     * Emits an event when this untitled model is reverted.
+     */
+    readonly onDidRevert: Event<void>;
+    /**
+     * Whether this untitled text model has an associated file path.
+     */
+    readonly hasAssociatedFilePath: boolean;
+    /**
+     * Whether this model has an explicit language or not.
+     */
+    readonly hasLanguageSetExplicitly: boolean;
+    /**
+     * Sets the encoding to use for this untitled model.
+     */
+    setEncoding(encoding: string): Promise<void>;
+    /**
+     * Resolves the untitled model.
+     */
+    resolve(): Promise<void>;
+}
+
+interface INewUntitledTextEditorOptions {
+    /**
+     * Initial value of the untitled editor. An untitled editor with initial
+     * value is dirty right from the beginning.
+     */
+    initialValue?: string;
+    /**
+     * Preferred language id to use when saving the untitled editor.
+     */
+    languageId?: string;
+    /**
+     * Preferred encoding to use when saving the untitled editor.
+     */
+    encoding?: string;
+}
+interface IExistingUntitledTextEditorOptions extends INewUntitledTextEditorOptions {
+    /**
+     * A resource to identify the untitled editor to create or return
+     * if already existing.
+     *
+     * Note: the resource will not be used unless the scheme is `untitled`.
+     */
+    untitledResource?: URI;
+}
+interface INewUntitledTextEditorWithAssociatedResourceOptions extends INewUntitledTextEditorOptions {
+    /**
+     * Resource components to associate with the untitled editor. When saving
+     * the untitled editor, the associated components will be used and the user
+     * is not being asked to provide a file path.
+     *
+     * Note: currently it is not possible to specify the `scheme` to use. The
+     * untitled editor will saved to the default local or remote resource.
+     */
+    associatedResource?: {
+        authority: string;
+        path: string;
+        query: string;
+        fragment: string;
+    };
+}
+interface IUntitledTextEditorModelManager {
+    /**
+     * 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 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;
+}
+
+/**
+ * A resource based `IWorkingCopy` is backed by a `URI` from a
+ * known file system provider.
+ */
+interface IResourceWorkingCopy extends IWorkingCopy, IDisposable {
+    /**
+     * An event for when the orphaned state of the resource working copy changes.
+     */
+    readonly onDidChangeOrphaned: Event<void>;
+    /**
+     * Whether the resource working copy is orphaned or not.
+     */
+    isOrphaned(): boolean;
+    /**
+     * An event for when the file working copy has been disposed.
+     */
+    readonly onWillDispose: Event<void>;
+    /**
+     * Whether the file working copy has been disposed or not.
+     */
+    isDisposed(): boolean;
+}
+
+/**
+ * A generic file working copy model to be reused by untitled
+ * and stored file working copies.
+ */
+interface IFileWorkingCopyModel extends IDisposable {
+    /**
+     * This event signals ANY changes to the contents, for example:
+     * - through the user typing into the editor
+     * - from API usage (e.g. bulk edits)
+     * - when `IFileWorkingCopyModel#update` is invoked with contents
+     *   that are different from the current contents
+     *
+     * The file working copy will listen to these changes and may mark
+     * the working copy as dirty whenever this event fires.
+     *
+     * Note: ONLY report changes to the model but not the underlying
+     * file. The file working copy is tracking changes to the file
+     * automatically.
+     */
+    readonly onDidChangeContent: Event<unknown>;
+    /**
+     * An event emitted right before disposing the model.
+     */
+    readonly onWillDispose: Event<void>;
+    /**
+     * Snapshots the model's current content for writing. This must include
+     * any changes that were made to the model that are in memory.
+     *
+     * @param token support for cancellation
+     */
+    snapshot(token: CancellationToken): Promise<VSBufferReadableStream>;
+    /**
+     * Updates the model with the provided contents. The implementation should
+     * behave in a similar fashion as `IFileWorkingCopyModelFactory#createModel`
+     * except that here the model already exists and just needs to update to
+     * the provided contents.
+     *
+     * Note: it is expected that the model fires a `onDidChangeContent` event
+     * as part of the update.
+     *
+     * @param contents the contents to use for the model
+     * @param token support for cancellation
+     */
+    update(contents: VSBufferReadableStream, token: CancellationToken): Promise<void>;
+}
+interface IFileWorkingCopy<M extends IFileWorkingCopyModel> extends IWorkingCopy, IDisposable {
+    /**
+     * An event for when the file working copy has been reverted.
+     */
+    readonly onDidRevert: Event<void>;
+    /**
+     * An event for when the file working copy has been disposed.
+     */
+    readonly onWillDispose: Event<void>;
+    /**
+     * Provides access to the underlying model of this file
+     * based working copy. As long as the file working copy
+     * has not been resolved, the model is `undefined`.
+     */
+    readonly model: M | undefined;
+    /**
+     * Resolves the file working copy and thus makes the `model`
+     * available.
+     */
+    resolve(): Promise<void>;
+    /**
+     * Whether we have a resolved model or not.
+     */
+    isResolved(): this is IResolvedFileWorkingCopy<M>;
+}
+interface IResolvedFileWorkingCopy<M extends IFileWorkingCopyModel> extends IFileWorkingCopy<M> {
+    /**
+     * A resolved file working copy has a resolved model.
+     */
+    readonly model: M;
+}
+
+/**
+ * The underlying model of a stored file working copy provides some
+ * methods for the stored file working copy to function. The model is
+ * typically only available after the working copy has been
+ * resolved via it's `resolve()` method.
+ */
+interface IStoredFileWorkingCopyModel extends IFileWorkingCopyModel {
+    readonly onDidChangeContent: Event<IStoredFileWorkingCopyModelContentChangedEvent>;
+    /**
+     * A version ID of the model. If a `onDidChangeContent` is fired
+     * from the model and the last known saved `versionId` matches
+     * with the `model.versionId`, the stored file working copy will
+     * discard any dirty state.
+     *
+     * A use case is the following:
+     * - a stored file working copy gets edited and thus dirty
+     * - the user triggers undo to revert the changes
+     * - at this point the `versionId` should match the one we had saved
+     *
+     * This requires the model to be aware of undo/redo operations.
+     */
+    readonly versionId: unknown;
+    /**
+     * Close the current undo-redo element. This offers a way
+     * to create an undo/redo stop point.
+     *
+     * This method may for example be called right before the
+     * save is triggered so that the user can always undo back
+     * to the state before saving.
+     */
+    pushStackElement(): void;
+}
+interface IStoredFileWorkingCopyModelContentChangedEvent {
+    /**
+     * Flag that indicates that this event was generated while undoing.
+     */
+    readonly isUndoing: boolean;
+    /**
+     * Flag that indicates that this event was generated while redoing.
+     */
+    readonly isRedoing: boolean;
+}
+/**
+ * A stored file based `IWorkingCopy` is backed by a `URI` from a
+ * known file system provider. Given this assumption, a lot
+ * of functionality can be built on top, such as saving in
+ * a secure way to prevent data loss.
+ */
+interface IStoredFileWorkingCopy<M extends IStoredFileWorkingCopyModel> extends IResourceWorkingCopy, IFileWorkingCopy<M> {
+    /**
+     * An event for when a stored file working copy was resolved.
+     */
+    readonly onDidResolve: Event<void>;
+    /**
+     * An event for when a stored file working copy was saved successfully.
+     */
+    readonly onDidSave: Event<IStoredFileWorkingCopySaveEvent>;
+    /**
+     * An event indicating that a stored file working copy save operation failed.
+     */
+    readonly onDidSaveError: Event<void>;
+    /**
+     * An event for when the readonly state of the stored file working copy changes.
+     */
+    readonly onDidChangeReadonly: Event<void>;
+    /**
+     * Resolves a stored file working copy.
+     */
+    resolve(options?: IStoredFileWorkingCopyResolveOptions): Promise<void>;
+    /**
+     * Explicitly sets the working copy to be modified.
+     */
+    markModified(): void;
+    /**
+     * Whether the stored file working copy is in the provided `state`
+     * or not.
+     *
+     * @param state the `FileWorkingCopyState` to check on.
+     */
+    hasState(state: StoredFileWorkingCopyState): boolean;
+    /**
+     * Allows to join a state change away from the provided `state`.
+     *
+     * @param state currently only `FileWorkingCopyState.PENDING_SAVE`
+     * can be awaited on to resolve.
+     */
+    joinState(state: StoredFileWorkingCopyState.PENDING_SAVE): Promise<void>;
+    /**
+     * Whether we have a resolved model or not.
+     */
+    isResolved(): this is IResolvedStoredFileWorkingCopy<M>;
+    /**
+     * Whether the stored file working copy is readonly or not.
+     */
+    isReadonly(): boolean;
+}
+interface IResolvedStoredFileWorkingCopy<M extends IStoredFileWorkingCopyModel> extends IStoredFileWorkingCopy<M> {
+    /**
+     * A resolved stored file working copy has a resolved model.
+     */
+    readonly model: M;
+}
+/**
+ * States the stored file working copy can be in.
+ */
+declare const enum StoredFileWorkingCopyState {
+    /**
+     * A stored file working copy is saved.
+     */
+    SAVED = 0,
+    /**
+     * A stored file working copy is dirty.
+     */
+    DIRTY = 1,
+    /**
+     * A stored file working copy is currently being saved but
+     * this operation has not completed yet.
+     */
+    PENDING_SAVE = 2,
+    /**
+     * A stored file working copy is in conflict mode when changes
+     * cannot be saved because the underlying file has changed.
+     * Stored file working copies in conflict mode are always dirty.
+     */
+    CONFLICT = 3,
+    /**
+     * A stored file working copy 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 `StoredFileWorkingCopyState.CONFLICT` state.
+     * Stored file working copies in error mode are always dirty.
+     */
+    ERROR = 5
+}
+interface IStoredFileWorkingCopyResolveOptions {
+    /**
+     * The contents to use for the stored file working copy if known. If not
+     * provided, the contents will be retrieved from the underlying
+     * resource or backup if present.
+     *
+     * If contents are provided, the stored file working copy will be marked
+     * as dirty right from the beginning.
+     */
+    readonly contents?: VSBufferReadableStream;
+    /**
+     * Go to disk bypassing any cache of the stored file working copy if any.
+     */
+    readonly forceReadFromFile?: boolean;
+}
+interface IStoredFileWorkingCopySaveEvent extends IWorkingCopySaveEvent {
+    /**
+     * The resolved stat from the save operation.
+     */
+    readonly stat: IFileStatWithMetadata;
+}
+
+interface SourceTargetPair {
+    /**
+     * The source resource that is defined for move operations.
+     */
+    readonly source?: URI;
+    /**
+     * The target resource the event is about.
+     */
+    readonly target: URI;
+}
+interface IFileOperationUndoRedoInfo {
+    /**
+     * Id of the undo group that the file operation belongs to.
+     */
+    undoRedoGroupId?: number;
+    /**
+     * Flag indicates if the operation is an undo.
+     */
+    isUndoing?: boolean;
+}
+interface WorkingCopyFileEvent extends IWaitUntil {
+    /**
+     * An identifier to correlate the operation through the
+     * different event types (before, after, error).
+     */
+    readonly correlationId: number;
+    /**
+     * The file operation that is taking place.
+     */
+    readonly operation: FileOperation;
+    /**
+     * The array of source/target pair of files involved in given operation.
+     */
+    readonly files: readonly SourceTargetPair[];
+}
+interface IWorkingCopyFileOperationParticipant {
+    /**
+     * Participate in a file operation of working copies. Allows to
+     * change the working copies before they are being saved to disk.
+     */
+    participate(files: SourceTargetPair[], operation: FileOperation, undoInfo: IFileOperationUndoRedoInfo | undefined, timeout: number, token: CancellationToken): Promise<void>;
+}
+interface IStoredFileWorkingCopySaveParticipant {
+    /**
+     * Participate in a save operation of file stored working copies.
+     * Allows to make changes before content is being saved to disk.
+     */
+    participate(workingCopy: IStoredFileWorkingCopy<IStoredFileWorkingCopyModel>, context: {
+        reason: SaveReason;
+    }, progress: IProgress<IProgressStep>, token: CancellationToken): Promise<void>;
+}
+interface ICreateOperation {
+    resource: URI;
+    overwrite?: boolean;
+}
+interface ICreateFileOperation extends ICreateOperation {
+    contents?: VSBuffer | VSBufferReadable | VSBufferReadableStream;
+}
+interface IDeleteOperation {
+    resource: URI;
+    useTrash?: boolean;
+    recursive?: boolean;
+}
+interface IMoveOperation {
+    file: Required<SourceTargetPair>;
+    overwrite?: boolean;
+}
+interface ICopyOperation extends IMoveOperation {
+}
+/**
+ * Returns the working copies for a given resource.
+ */
+type WorkingCopyProvider = (resourceOrFolder: URI) => IWorkingCopy[];
+
+declare const IWorkingCopyFileService: ServiceIdentifier<IWorkingCopyFileService>;
+/**
+ * A service that allows to perform file operations with working copy support.
+ * Any operation that would leave a stale dirty working copy behind will make
+ * sure to revert the working copy first.
+ *
+ * On top of that events are provided to participate in each state of the
+ * operation to perform additional work.
+ */
+interface IWorkingCopyFileService {
+    readonly _serviceBrand: undefined;
+    /**
+     * An event that is fired when a certain working copy IO operation is about to run.
+     *
+     * Participants can join this event with a long running operation to keep some state
+     * before the operation is started, but working copies should not be changed at this
+     * point in time. For that purpose, use the `IWorkingCopyFileOperationParticipant` API.
+     */
+    readonly onWillRunWorkingCopyFileOperation: Event<WorkingCopyFileEvent>;
+    /**
+     * An event that is fired after a working copy IO operation has failed.
+     *
+     * Participants can join this event with a long running operation to clean up as needed.
+     */
+    readonly onDidFailWorkingCopyFileOperation: Event<WorkingCopyFileEvent>;
+    /**
+     * An event that is fired after a working copy IO operation has been performed.
+     *
+     * Participants can join this event with a long running operation to make changes
+     * after the operation has finished.
+     */
+    readonly onDidRunWorkingCopyFileOperation: Event<WorkingCopyFileEvent>;
+    /**
+     * Adds a participant for file operations on working copies.
+     */
+    addFileOperationParticipant(participant: IWorkingCopyFileOperationParticipant): IDisposable;
+    /**
+     * Whether save participants are present for stored file working copies.
+     */
+    get hasSaveParticipants(): boolean;
+    /**
+     * Adds a participant for save operations on stored file working copies.
+     */
+    addSaveParticipant(participant: IStoredFileWorkingCopySaveParticipant): IDisposable;
+    /**
+     * Runs all available save participants for stored file working copies.
+     */
+    runSaveParticipants(workingCopy: IStoredFileWorkingCopy<IStoredFileWorkingCopyModel>, context: {
+        reason: SaveReason;
+    }, token: CancellationToken): Promise<void>;
+    /**
+     * Will create a resource with the provided optional contents, optionally overwriting any target.
+     *
+     * Working copy owners can listen to the `onWillRunWorkingCopyFileOperation` and
+     * `onDidRunWorkingCopyFileOperation` events to participate.
+     */
+    create(operations: ICreateFileOperation[], token: CancellationToken, undoInfo?: IFileOperationUndoRedoInfo): Promise<readonly IFileStatWithMetadata[]>;
+    /**
+     * Will create a folder and any parent folder that needs to be created.
+     *
+     * Working copy owners can listen to the `onWillRunWorkingCopyFileOperation` and
+     * `onDidRunWorkingCopyFileOperation` events to participate.
+     *
+     * Note: events will only be emitted for the provided resource, but not any
+     * parent folders that are being created as part of the operation.
+     */
+    createFolder(operations: ICreateOperation[], token: CancellationToken, undoInfo?: IFileOperationUndoRedoInfo): Promise<readonly IFileStatWithMetadata[]>;
+    /**
+     * Will move working copies matching the provided resources and corresponding children
+     * to the target resources using the associated file service for those resources.
+     *
+     * Working copy owners can listen to the `onWillRunWorkingCopyFileOperation` and
+     * `onDidRunWorkingCopyFileOperation` events to participate.
+     */
+    move(operations: IMoveOperation[], token: CancellationToken, undoInfo?: IFileOperationUndoRedoInfo): Promise<readonly IFileStatWithMetadata[]>;
+    /**
+     * Will copy working copies matching the provided resources and corresponding children
+     * to the target resources using the associated file service for those resources.
+     *
+     * Working copy owners can listen to the `onWillRunWorkingCopyFileOperation` and
+     * `onDidRunWorkingCopyFileOperation` events to participate.
+     */
+    copy(operations: ICopyOperation[], token: CancellationToken, undoInfo?: IFileOperationUndoRedoInfo): Promise<readonly IFileStatWithMetadata[]>;
+    /**
+     * Will delete working copies matching the provided resources and children
+     * using the associated file service for those resources.
+     *
+     * Working copy owners can listen to the `onWillRunWorkingCopyFileOperation` and
+     * `onDidRunWorkingCopyFileOperation` events to participate.
+     */
+    delete(operations: IDeleteOperation[], token: CancellationToken, undoInfo?: IFileOperationUndoRedoInfo): Promise<void>;
+    /**
+     * Register a new provider for working copies based on a resource.
+     *
+     * @return a disposable that unregisters the provider.
+     */
+    registerWorkingCopyProvider(provider: WorkingCopyProvider): IDisposable;
+    /**
+     * Will return all working copies that are dirty matching the provided resource.
+     * If the resource is a folder and the scheme supports file operations, a working
+     * copy that is dirty and is a child of that folder will also be returned.
+     */
+    getDirty(resource: URI): readonly IWorkingCopy[];
+}
+
+declare const ITextFileService: ServiceIdentifier<ITextFileService>;
+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;
+        options?: {
+            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, value: ITextSnapshot, options?: IWriteTextFileOptions): Promise<VSBufferReadable>;
+    getEncodedReadable(resource: URI, value: string, options?: IWriteTextFileOptions): Promise<VSBuffer>;
+    getEncodedReadable(resource: URI, value?: ITextSnapshot, options?: IWriteTextFileOptions): Promise<VSBufferReadable | undefined>;
+    getEncodedReadable(resource: URI, value?: string, options?: IWriteTextFileOptions): Promise<VSBuffer | undefined>;
+    getEncodedReadable(resource: URI, 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, value: VSBufferReadableStream, options?: IReadTextFileEncodingOptions): Promise<ReadableStream<string>>;
+}
+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 acceptTextOnly parameter allows to fail this request early if the file
+     * contents are not textual.
+     */
+    readonly acceptTextOnly?: boolean;
+}
+interface IReadTextFileOptions extends IReadTextFileEncodingOptions, IReadFileStreamOptions {
+}
+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;
+}
+interface IResourceEncodings {
+    getPreferredReadEncoding(resource: URI): Promise<IResourceEncoding>;
+    getPreferredWriteEncoding(resource: URI, preferredEncoding?: string): Promise<IResourceEncoding>;
+}
+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.
+ */
+interface ISaveErrorHandler {
+    /**
+     * Called whenever a save fails.
+     */
+    onSaveError(error: Error, model: ITextFileEditorModel): void;
+}
+/**
+ * States the text file editor model can be in.
+ */
+declare const 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
+}
+declare const enum TextFileResolveReason {
+    EDITOR = 1,
+    REFERENCE = 2,
+    OTHER = 3
+}
+interface IBaseTextFileContent extends IBaseFileStatWithMetadata {
+    /**
+     * The encoding of the content if known.
+     */
+    readonly encoding: string;
+}
+interface ITextFileContent extends IBaseTextFileContent {
+    /**
+     * The content of a text file.
+     */
+    readonly value: string;
+}
+interface ITextFileStreamContent extends IBaseTextFileContent {
+    /**
+     * The line grouped content of a text file.
+     */
+    readonly value: ITextBufferFactory;
+}
+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;
+    };
+}
+interface ITextFileSaveEvent extends ITextFileEditorModelSaveEvent {
+    /**
+     * The model that was saved.
+     */
+    readonly model: ITextFileEditorModel;
+}
+interface ITextFileResolveEvent {
+    /**
+     * The model that was resolved.
+     */
+    readonly model: ITextFileEditorModel;
+    /**
+     * The reason why the model was resolved.
+     */
+    readonly reason: TextFileResolveReason;
+}
+interface ITextFileSaveParticipant {
+    /**
+     * Participate in a save of a model. Allows to change the model
+     * before it is being saved to disk.
+     */
+    participate(model: ITextFileEditorModel, context: {
+        reason: SaveReason;
+    }, progress: IProgress<IProgressStep>, token: CancellationToken): Promise<void>;
+}
+interface ITextFileEditorModelManager {
+    readonly onDidCreate: Event<ITextFileEditorModel>;
+    readonly onDidResolve: Event<ITextFileResolveEvent>;
+    readonly onDidChangeDirty: Event<ITextFileEditorModel>;
+    readonly onDidChangeReadonly: Event<ITextFileEditorModel>;
+    readonly onDidRemove: Event<URI>;
+    readonly onDidChangeOrphaned: Event<ITextFileEditorModel>;
+    readonly onDidChangeEncoding: Event<ITextFileEditorModel>;
+    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: {
+        reason: SaveReason;
+    }, 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>;
+}
+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;
+}
+interface ITextFileSaveAsOptions extends ITextFileSaveOptions {
+    /**
+     * Optional URI to use as suggested file path to save as.
+     */
+    readonly suggestedTarget?: URI;
+}
+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;
+}
+declare const 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
+}
+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>;
+}
+interface ILanguageSupport {
+    /**
+     * Sets the language id of the object.
+     */
+    setLanguageId(languageId: string, source?: string): void;
+}
+interface ITextFileEditorModelSaveEvent extends IWorkingCopySaveEvent {
+    /**
+     * The resolved stat from the save operation.
+     */
+    readonly stat: IFileStatWithMetadata;
+}
+interface ITextFileEditorModel extends ITextEditorModel, IEncodingSupport, ILanguageSupport, IWorkingCopy {
+    readonly onDidSave: Event<ITextFileEditorModelSaveEvent>;
+    readonly onDidSaveError: Event<void>;
+    readonly onDidChangeOrphaned: Event<void>;
+    readonly onDidChangeReadonly: Event<void>;
+    readonly onDidChangeEncoding: Event<void>;
+    hasState(state: TextFileEditorModelState): boolean;
+    joinState(state: TextFileEditorModelState.PENDING_SAVE): Promise<void>;
+    updatePreferredEncoding(encoding: string | undefined): void;
+    save(options?: ITextFileSaveOptions): Promise<boolean>;
+    revert(options?: IRevertOptions): Promise<void>;
+    resolve(options?: ITextFileResolveOptions): Promise<void>;
+    isDirty(): this is IResolvedTextFileEditorModel;
+    getLanguageId(): string | undefined;
+    isResolved(): this is IResolvedTextFileEditorModel;
+}
+interface IResolvedTextFileEditorModel extends ITextFileEditorModel {
+    readonly textEditorModel: ITextModel;
+    createSnapshot(): ITextSnapshot;
+}
+
 interface IEditorDescriptor<T extends IEditorPane> {
     /**
      * The unique type identifier of the editor. All instances
@@ -1461,10 +2558,92 @@ declare const enum EditorInputCapabilities {
 type IUntypedEditorInput = IResourceEditorInput | ITextResourceEditorInput | IUntitledTextResourceEditorInput | IResourceDiffEditorInput | IResourceSideBySideEditorInput | IResourceMergeEditorInput;
 declare abstract class AbstractEditorInput extends Disposable {
 }
+interface EditorInputWithPreferredResource {
+    /**
+     * An editor may provide an additional preferred resource alongside
+     * the `resource` property. While the `resource` property serves as
+     * unique identifier of the editor that should be used whenever we
+     * compare to other editors, the `preferredResource` should be used
+     * in places where e.g. the resource is shown to the user.
+     *
+     * For example: on Windows and macOS, the same URI with different
+     * casing may point to the same file. The editor may chose to
+     * "normalize" the URIs so that only one editor opens for different
+     * URIs. But when displaying the editor label to the user, the
+     * preferred URI should be used.
+     *
+     * Not all editors have a `preferredResource`. The `EditorResourceAccessor`
+     * utility can be used to always get the right resource without having
+     * to do instanceof checks.
+     */
+    readonly preferredResource: URI;
+}
+interface IUntypedFileEditorInput extends ITextResourceEditorInput {
+    /**
+     * A marker to create a `IFileEditorInput` from this untyped input.
+     */
+    forceFile: true;
+}
+/**
+ * This is a tagging interface to declare an editor input being capable of dealing with files. It is only used in the editor registry
+ * to register this kind of input to the platform.
+ */
+interface IFileEditorInput extends EditorInput, IEncodingSupport, ILanguageSupport, EditorInputWithPreferredResource {
+    /**
+     * Gets the resource this file input is about. This will always be the
+     * canonical form of the resource, so it may differ from the original
+     * resource that was provided to create the input. Use `preferredResource`
+     * for the form as it was created.
+     */
+    readonly resource: URI;
+    /**
+     * Sets the preferred resource to use for this file input.
+     */
+    setPreferredResource(preferredResource: URI): void;
+    /**
+     * Sets the preferred name to use for this file input.
+     *
+     * Note: for certain file schemes the input may decide to ignore this
+     * name and use our standard naming. Specifically for schemes we own,
+     * we do not let others override the name.
+     */
+    setPreferredName(name: string): void;
+    /**
+     * Sets the preferred description to use for this file input.
+     *
+     * Note: for certain file schemes the input may decide to ignore this
+     * description and use our standard naming. Specifically for schemes we own,
+     * we do not let others override the description.
+     */
+    setPreferredDescription(description: string): void;
+    /**
+     * Sets the preferred encoding to use for this file input.
+     */
+    setPreferredEncoding(encoding: string): void;
+    /**
+     * Sets the preferred language id to use for this file input.
+     */
+    setPreferredLanguageId(languageId: string): void;
+    /**
+     * Sets the preferred contents to use for this file input.
+     */
+    setPreferredContents(contents: string): void;
+    /**
+     * Forces this file input to open as binary instead of text.
+     */
+    setForceOpenAsBinary(): void;
+    /**
+     * Figure out if the file input has been resolved or not.
+     */
+    isResolved(): boolean;
+}
 interface EditorInputWithOptions {
     editor: EditorInput;
     options?: IEditorOptions;
 }
+interface EditorInputWithOptionsAndGroup extends EditorInputWithOptions {
+    group: IEditorGroup;
+}
 interface IEditorIdentifier {
     groupId: GroupIdentifier;
     editor: EditorInput;
@@ -1626,4 +2805,4 @@ declare const enum EditorsOrder {
     SEQUENTIAL = 1
 }
 
-export { ICheckbox as $, IAddGroupOptions as A, IMergeGroupOptions as B, ICloseEditorsFilter as C, ICloseAllEditorsOptions as D, EditorInput as E, GroupsOrder as F, GroupIdentifier as G, IEditorSideGroup as H, IEditorCloseEvent as I, CloseDirection as J, IEditorPartOptions as K, IEditorPartOptionsChangeEvent as L, MergeGroupMode as M, IEditorWillMoveEvent as N, IEditorWillOpenEvent as O, IMatchEditorOptions as P, IActiveEditorChangeEvent as Q, IEditorControl as R, SaveReason as S, IDialogArgs as T, DialogType as U, IDialogResult as V, IDialogHandler as W, IConfirmDialogArgs as X, IInputDialogArgs as Y, IPromptDialogArgs as Z, IBaseDialogOptions as _, IVisibleEditorPane as a, ICheckboxResult as a0, ICustomDialogOptions as a1, ICustomDialogMarkdown as a2, IConfirmation as a3, IConfirmationResult as a4, IInput as a5, IInputResult as a6, IInputElement as a7, IPrompt as a8, IPromptResult as a9, IPromptBaseButton as aa, IPromptButton as ab, IPromptCancelButton as ac, IPromptResultWithCancel as ad, IPromptWithCustomCancel as ae, IPromptWithDefaultCancel as af, EditorsOrder as b, IEditorIdentifier as c, IEditorPane as d, IUntypedEditorInput as e, IUntitledTextResourceEditorInput as f, IResourceDiffEditorInput as g, ITextDiffEditorPane as h, EditorInputWithOptions as i, IEditorReplacement as j, IEditorGroup as k, IFindEditorOptions as l, IRevertOptions as m, ICloseEditorOptions as n, ISaveOptions as o, IGroupModelChangeEvent as p, SaveSource as q, IDialogService as r, IEditorGroupsService as s, GroupDirection as t, GroupOrientation as u, GroupLocation as v, IFindGroupScope as w, GroupsArrangement as x, GroupLayoutArgument as y, EditorGroupLayout as z };
+export { IDialogHandler as $, IFindGroupScope as A, GroupsArrangement as B, GroupLayoutArgument as C, EditorGroupLayout as D, EditorInput as E, IAddGroupOptions as F, GroupIdentifier as G, IMergeGroupOptions as H, IEditorCloseEvent as I, ICloseEditorsFilter as J, ICloseAllEditorsOptions as K, GroupsOrder as L, MergeGroupMode as M, IEditorSideGroup as N, CloseDirection as O, IEditorPartOptions as P, IEditorPartOptionsChangeEvent as Q, IEditorWillMoveEvent as R, IEditorWillOpenEvent as S, IMatchEditorOptions as T, IActiveEditorChangeEvent as U, IEditorControl as V, ITextFileService as W, IWorkingCopyFileService as X, IDialogArgs as Y, DialogType as Z, IDialogResult as _, IVisibleEditorPane as a, IConfirmDialogArgs as a0, IInputDialogArgs as a1, IPromptDialogArgs as a2, IBaseDialogOptions as a3, ICheckbox as a4, ICheckboxResult as a5, ICustomDialogOptions as a6, ICustomDialogMarkdown as a7, IConfirmation as a8, IConfirmationResult as a9, IInput as aa, IInputResult as ab, IInputElement as ac, IPrompt as ad, IPromptResult as ae, IPromptBaseButton as af, IPromptButton as ag, IPromptCancelButton as ah, IPromptResultWithCancel as ai, IPromptWithCustomCancel as aj, IPromptWithDefaultCancel as ak, EditorsOrder as b, IEditorIdentifier as c, IEditorPane as d, IUntypedEditorInput as e, IUntitledTextResourceEditorInput as f, IResourceDiffEditorInput as g, ITextDiffEditorPane as h, EditorInputWithOptions as i, IEditorReplacement as j, IEditorGroup as k, IFindEditorOptions as l, IRevertOptions as m, ICloseEditorOptions as n, ISaveOptions as o, IGroupModelChangeEvent as p, ITextFileEditorModel as q, EditorInputWithOptionsAndGroup as r, IResourceMergeEditorInput as s, IUntypedFileEditorInput as t, IFileEditorInput as u, IDialogService as v, IEditorGroupsService as w, GroupDirection as x, GroupOrientation as y, GroupLocation as z };