@codingame/monaco-vscode-files-service-override 11.1.2 → 12.0.0

package/package.json

@@ -1,6 +1,8 @@
 {
   "name": "@codingame/monaco-vscode-files-service-override",
-  "version": "11.1.2",
+  "version": "12.0.0",
+  "private": false,
+  "description": "VSCode public API plugged on the monaco editor - files service-override",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -12,8 +14,28 @@
     "url": "git+ssh://git@github.com/CodinGame/monaco-vscode-api.git"
   },
   "type": "module",
-  "private": false,
-  "description": "VSCode public API plugged on the monaco editor - files service-override",
+  "dependencies": {
+    "@codingame/monaco-vscode-0c06bfba-d24d-5c4d-90cd-b40cefb7f811-common": "12.0.0",
+    "@codingame/monaco-vscode-15626ec7-b165-51e1-8caf-7bcc2ae9b95a-common": "12.0.0",
+    "@codingame/monaco-vscode-2e67e044-0db9-5fa6-8bd1-3737a7d586d4-common": "12.0.0",
+    "@codingame/monaco-vscode-2f06fe84-148e-5e6b-a7ca-c7989c5f128a-common": "12.0.0",
+    "@codingame/monaco-vscode-a4683c2b-a0d2-5112-96ba-eedc605346d2-common": "12.0.0",
+    "@codingame/monaco-vscode-cea4d01f-6526-5c2f-8b09-b168fead499f-common": "12.0.0",
+    "@codingame/monaco-vscode-e571cbbb-526b-5d8b-92c5-a0437d2dabb3-common": "12.0.0",
+    "vscode": "npm:@codingame/monaco-vscode-api@12.0.0"
+  },
+  "peerDependencies": {
+    "@codingame/monaco-vscode-base-service-override": "12.0.0",
+    "@codingame/monaco-vscode-view-common-service-override": "12.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@codingame/monaco-vscode-base-service-override": {
+      "optional": true
+    },
+    "@codingame/monaco-vscode-view-common-service-override": {
+      "optional": true
+    }
+  },
   "main": "index.js",
   "module": "index.js",
   "types": "index.d.ts",
@@ -22,10 +44,12 @@
       "default": "./index.js"
     },
     "./vscode/*": {
-      "default": "./vscode/src/*.js"
+      "default": "./vscode/src/*.js",
+      "types": "./vscode/src/*.d.ts"
+    },
+    "./*": {
+      "default": "./*.js",
+      "types": "./*.d.ts"
     }
-  },
-  "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@11.1.2"
   }
 }

package/vscode/src/vs/platform/files/browser/indexedDBFileSystemProvider.d.ts

@@ -0,0 +1,68 @@
+import { Event } from "vscode/vscode/vs/base/common/event";
+import { Disposable, IDisposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { URI } from "vscode/vscode/vs/base/common/uri";
+import { IFileDeleteOptions, IFileOverwriteOptions, FileSystemProviderCapabilities, FileType, IFileWriteOptions, IFileChange, IFileSystemProviderWithFileReadWriteCapability, IStat, IWatchOptions } from "vscode/vscode/vs/platform/files/common/files";
+import { IndexedDB } from "@codingame/monaco-vscode-2f06fe84-148e-5e6b-a7ca-c7989c5f128a-common/vscode/vs/base/browser/indexedDB";
+export type IndexedDBFileSystemProviderErrorDataClassification = {
+    owner: "sandy081";
+    comment: "Information about errors that occur in the IndexedDB file system provider";
+    readonly scheme: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "IndexedDB file system provider scheme for which this error occurred";
+    };
+    readonly operation: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "operation during which this error occurred";
+    };
+    readonly code: {
+        classification: "SystemMetaData";
+        purpose: "PerformanceAndHealth";
+        comment: "error code";
+    };
+};
+export type IndexedDBFileSystemProviderErrorData = {
+    readonly scheme: string;
+    readonly operation: string;
+    readonly code: string;
+};
+type DirEntry = [
+    string,
+    FileType
+];
+export declare class IndexedDBFileSystemProvider extends Disposable implements IFileSystemProviderWithFileReadWriteCapability {
+    readonly scheme: string;
+    private indexedDB;
+    private readonly store;
+    readonly capabilities: FileSystemProviderCapabilities;
+    readonly onDidChangeCapabilities: Event<void>;
+    private readonly extUri;
+    private readonly changesBroadcastChannel;
+    private readonly _onDidChangeFile;
+    readonly onDidChangeFile: Event<readonly IFileChange[]>;
+    private readonly _onReportError;
+    readonly onReportError: Event<IndexedDBFileSystemProviderErrorData>;
+    private readonly mtimes;
+    private cachedFiletree;
+    private writeManyThrottler;
+    constructor(scheme: string, indexedDB: IndexedDB, store: string, watchCrossWindowChanges: boolean);
+    watch(resource: URI, opts: IWatchOptions): IDisposable;
+    mkdir(resource: URI): Promise<void>;
+    stat(resource: URI): Promise<IStat>;
+    readdir(resource: URI): Promise<DirEntry[]>;
+    readFile(resource: URI): Promise<Uint8Array>;
+    writeFile(resource: URI, content: Uint8Array, opts: IFileWriteOptions): Promise<void>;
+    rename(from: URI, to: URI, opts: IFileOverwriteOptions): Promise<void>;
+    delete(resource: URI, opts: IFileDeleteOptions): Promise<void>;
+    private tree;
+    private triggerChanges;
+    private getFiletree;
+    private bulkWrite;
+    private fileWriteBatch;
+    private writeMany;
+    private deleteKeys;
+    reset(): Promise<void>;
+    private reportError;
+}
+export {};

package/vscode/src/vs/platform/files/browser/indexedDBFileSystemProvider.js

@@ -1,3 +1,4 @@
+
 import { Throttler } from 'vscode/vscode/vs/base/common/async';
 import { VSBuffer } from 'vscode/vscode/vs/base/common/buffer';
 import { Event, Emitter } from 'vscode/vscode/vs/base/common/event';
@@ -6,17 +7,17 @@ import { ExtUri } from 'vscode/vscode/vs/base/common/resources';
 import { isString } from 'vscode/vscode/vs/base/common/types';
 import { URI } from 'vscode/vscode/vs/base/common/uri';
 import { localize } from 'vscode/vscode/vs/nls';
-import { createFileSystemProviderError, FileSystemProviderErrorCode, FileType, FileSystemProviderError } from 'vscode/vscode/vs/platform/files/common/files';
-import { DBClosedError } from 'vscode/vscode/vs/base/browser/indexedDB';
-import { BroadcastDataChannel } from 'vscode/vscode/vs/base/browser/broadcast';
+import { createFileSystemProviderError, FileSystemProviderErrorCode, FileType, FileSystemProviderCapabilities, FileChangeType, FileSystemProviderError } from 'vscode/vscode/vs/platform/files/common/files';
+import { DBClosedError } from '@codingame/monaco-vscode-2f06fe84-148e-5e6b-a7ca-c7989c5f128a-common/vscode/vs/base/browser/indexedDB';
+import { BroadcastDataChannel } from '@codingame/monaco-vscode-e571cbbb-526b-5d8b-92c5-a0437d2dabb3-common/vscode/vs/base/browser/broadcast';
 
-const ERR_FILE_NOT_FOUND = createFileSystemProviderError(( localize(617, "File does not exist")), FileSystemProviderErrorCode.FileNotFound);
-const ERR_FILE_IS_DIR = createFileSystemProviderError(( localize(618, "File is Directory")), FileSystemProviderErrorCode.FileIsADirectory);
-const ERR_FILE_NOT_DIR = createFileSystemProviderError(( localize(619, "File is not a directory")), FileSystemProviderErrorCode.FileNotADirectory);
-const ERR_DIR_NOT_EMPTY = createFileSystemProviderError(( localize(620, "Directory is not empty")), FileSystemProviderErrorCode.Unknown);
-const ERR_FILE_EXCEEDS_STORAGE_QUOTA = createFileSystemProviderError(( localize(621, "File exceeds available storage quota")), FileSystemProviderErrorCode.FileExceedsStorageQuota);
+const ERR_FILE_NOT_FOUND = createFileSystemProviderError(( localize(1741, "File does not exist")), FileSystemProviderErrorCode.FileNotFound);
+const ERR_FILE_IS_DIR = createFileSystemProviderError(( localize(1742, "File is Directory")), FileSystemProviderErrorCode.FileIsADirectory);
+const ERR_FILE_NOT_DIR = createFileSystemProviderError(( localize(1743, "File is not a directory")), FileSystemProviderErrorCode.FileNotADirectory);
+const ERR_DIR_NOT_EMPTY = createFileSystemProviderError(( localize(1744, "Directory is not empty")), FileSystemProviderErrorCode.Unknown);
+const ERR_FILE_EXCEEDS_STORAGE_QUOTA = createFileSystemProviderError(( localize(1745, "File exceeds available storage quota")), FileSystemProviderErrorCode.FileExceedsStorageQuota);
 const ERR_UNKNOWN_INTERNAL = (message) => createFileSystemProviderError(( localize(
-    622,
+    1746,
     "Internal error occurred in IndexedDB File System Provider. ({0})",
     message
 )), FileSystemProviderErrorCode.Unknown);
@@ -88,32 +89,32 @@ class IndexedDBFileSystemNode {
                 if (existing?.entry.type === FileType.File) {
                     throw ERR_UNKNOWN_INTERNAL(`Internal error creating IndexedDBFSNode -- overwriting file with directory: ${this.entry.path}/${next} (encountered while adding ${originalPath})`);
                 }
-                this.entry.children.set(next, existing ?? ( (new IndexedDBFileSystemNode({
+                this.entry.children.set(next, existing ?? ( new IndexedDBFileSystemNode({
                     type: FileType.Directory,
                     path: this.entry.path + '/' + next,
-                    children: ( (new Map())),
-                }))));
+                    children: ( new Map()),
+                })));
             }
             else {
                 if (existing?.entry.type === FileType.Directory) {
                     throw ERR_UNKNOWN_INTERNAL(`Internal error creating IndexedDBFSNode -- overwriting directory with file: ${this.entry.path}/${next} (encountered while adding ${originalPath})`);
                 }
-                this.entry.children.set(next, ( (new IndexedDBFileSystemNode({
+                this.entry.children.set(next, ( new IndexedDBFileSystemNode({
                     type: FileType.File,
                     path: this.entry.path + '/' + next,
                     size: entry.size,
-                }))));
+                })));
             }
         }
         else if (pathParts.length > 1) {
             const next = pathParts[0];
             let childNode = this.entry.children.get(next);
             if (!childNode) {
-                childNode = ( (new IndexedDBFileSystemNode({
-                    children: ( (new Map())),
+                childNode = ( new IndexedDBFileSystemNode({
+                    children: ( new Map()),
                     path: this.entry.path + '/' + next,
                     type: FileType.Directory
-                })));
+                }));
                 this.entry.children.set(next, childNode);
             }
             else if (childNode.type === FileType.File) {
@@ -135,21 +136,21 @@ class IndexedDBFileSystemProvider extends Disposable {
         this.scheme = scheme;
         this.indexedDB = indexedDB;
         this.store = store;
-        this.capabilities = 2
-            | 1024 ;
+        this.capabilities = FileSystemProviderCapabilities.FileReadWrite
+            | FileSystemProviderCapabilities.PathCaseSensitive;
         this.onDidChangeCapabilities = Event.None;
-        this.extUri = ( (new ExtUri(() => false))) ;
-        this._onDidChangeFile = this._register(( (new Emitter())));
+        this.extUri = ( new ExtUri(() => false)) ;
+        this._onDidChangeFile = this._register(( new Emitter()));
         this.onDidChangeFile = this._onDidChangeFile.event;
-        this._onReportError = this._register(( (new Emitter())));
+        this._onReportError = this._register(( new Emitter()));
         this.onReportError = this._onReportError.event;
-        this.mtimes = ( (new Map()));
+        this.mtimes = ( new Map());
         this.fileWriteBatch = [];
-        this.writeManyThrottler = ( (new Throttler()));
+        this.writeManyThrottler = ( new Throttler());
         if (watchCrossWindowChanges) {
-            this.changesBroadcastChannel = this._register(( (new BroadcastDataChannel(`vscode.indexedDB.${scheme}.changes`))));
+            this.changesBroadcastChannel = this._register(( new BroadcastDataChannel(`vscode.indexedDB.${scheme}.changes`)));
             this._register(this.changesBroadcastChannel.onDidReceiveData(changes => {
-                this._onDidChangeFile.fire(( (changes.map(c => ({ type: c.type, resource: URI.revive(c.resource) })))));
+                this._onDidChangeFile.fire(( changes.map(c => ({ type: c.type, resource: URI.revive(c.resource) }))));
             }));
         }
     }
@@ -172,7 +173,7 @@ class IndexedDBFileSystemProvider extends Disposable {
             return {
                 type: FileType.File,
                 ctime: 0,
-                mtime: this.mtimes.get(( (resource.toString()))) || 0,
+                mtime: this.mtimes.get(( resource.toString())) || 0,
                 size: entry.size ?? (await this.readFile(resource)).byteLength
             };
         }
@@ -196,9 +197,7 @@ class IndexedDBFileSystemProvider extends Disposable {
                 throw ERR_FILE_NOT_DIR;
             }
             else {
-                return (
-                     ([...entry.children.entries()].map(([name, node]) => [name, node.type]))
-                );
+                return ( [...entry.children.entries()].map(([name, node]) => [name, node.type]));
             }
         }
         catch (error) {
@@ -267,7 +266,7 @@ class IndexedDBFileSystemProvider extends Disposable {
         }
         if (sourceFiles.length) {
             const targetFiles = [];
-            const sourceFilesContents = await this.indexedDB.runInTransaction(this.store, 'readonly', objectStore => ( (sourceFiles.map(([path]) => objectStore.get(path)))));
+            const sourceFilesContents = await this.indexedDB.runInTransaction(this.store, 'readonly', objectStore => ( sourceFiles.map(([path]) => objectStore.get(path))));
             for (let index = 0; index < sourceFiles.length; index++) {
                 const content = sourceFilesContents[index] instanceof Uint8Array ? sourceFilesContents[index] : isString(sourceFilesContents[index]) ? VSBuffer.fromString(sourceFilesContents[index]).buffer : undefined;
                 if (content) {
@@ -292,7 +291,7 @@ class IndexedDBFileSystemProvider extends Disposable {
         let toDelete;
         if (opts.recursive) {
             const tree = await this.tree(resource);
-            toDelete = ( (tree.map(([path]) => path)));
+            toDelete = ( tree.map(([path]) => path));
         }
         else {
             if (stat.type === FileType.Directory && (await this.readdir(resource)).length) {
@@ -303,9 +302,9 @@ class IndexedDBFileSystemProvider extends Disposable {
         await this.deleteKeys(toDelete);
         (await this.getFiletree()).delete(resource.path);
         toDelete.forEach(key => this.mtimes.delete(key));
-        this.triggerChanges(( (toDelete.map(
-            path => ({ resource: resource.with({ path }), type: 2  })
-        ))));
+        this.triggerChanges(( toDelete.map(
+            path => ({ resource: resource.with({ path }), type: FileChangeType.DELETED })
+        )));
     }
     async tree(resource) {
         const stat = await this.stat(resource);
@@ -332,13 +331,13 @@ class IndexedDBFileSystemProvider extends Disposable {
     getFiletree() {
         if (!this.cachedFiletree) {
             this.cachedFiletree = (async () => {
-                const rootNode = ( (new IndexedDBFileSystemNode({
-                    children: ( (new Map())),
+                const rootNode = ( new IndexedDBFileSystemNode({
+                    children: ( new Map()),
                     path: '',
                     type: FileType.Directory
-                })));
+                }));
                 const result = await this.indexedDB.runInTransaction(this.store, 'readonly', objectStore => objectStore.getAllKeys());
-                const keys = ( (result.map(key => ( (key.toString())))));
+                const keys = ( result.map(key => ( key.toString())));
                 keys.forEach(key => rootNode.add(key, { type: 'file' }));
                 return rootNode;
             })();
@@ -351,17 +350,17 @@ class IndexedDBFileSystemProvider extends Disposable {
         const fileTree = await this.getFiletree();
         for (const [resource, content] of files) {
             fileTree.add(resource.path, { type: 'file', size: content.byteLength });
-            this.mtimes.set(( (resource.toString())), Date.now());
+            this.mtimes.set(( resource.toString()), Date.now());
         }
-        this.triggerChanges(( (files.map(([resource]) => ({ resource, type: 0  })))));
+        this.triggerChanges(( files.map(([resource]) => ({ resource, type: FileChangeType.UPDATED }))));
     }
     async writeMany() {
         if (this.fileWriteBatch.length) {
             const fileBatch = this.fileWriteBatch.splice(0, this.fileWriteBatch.length);
             try {
-                await this.indexedDB.runInTransaction(this.store, 'readwrite', objectStore => ( (fileBatch.map(entry => {
+                await this.indexedDB.runInTransaction(this.store, 'readwrite', objectStore => ( fileBatch.map(entry => {
                     return objectStore.put(entry.content, entry.resource.path);
-                }))));
+                })));
             }
             catch (ex) {
                 if (ex instanceof DOMException && ex.name === 'QuotaExceededError') {
@@ -373,7 +372,7 @@ class IndexedDBFileSystemProvider extends Disposable {
     }
     async deleteKeys(keys) {
         if (keys.length) {
-            await this.indexedDB.runInTransaction(this.store, 'readwrite', objectStore => ( (keys.map(key => objectStore.delete(key)))));
+            await this.indexedDB.runInTransaction(this.store, 'readwrite', objectStore => ( keys.map(key => objectStore.delete(key))));
         }
     }
     async reset() {

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

@@ -0,0 +1,113 @@
+import { VSBuffer, VSBufferReadable, VSBufferReadableStream } from "vscode/vscode/vs/base/common/buffer";
+import { CancellationToken } from "vscode/vscode/vs/base/common/cancellation";
+import { Disposable, IDisposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { IExtUri } from "vscode/vscode/vs/base/common/resources";
+import { URI } from "vscode/vscode/vs/base/common/uri";
+import { FileChangesEvent, IFileDeleteOptions, FileOperationEvent, FileSystemProviderCapabilities, ICreateFileOptions, IFileContent, IFileStat, IFileStatWithMetadata, IFileStreamContent, IFileSystemProvider, IFileSystemProviderActivationEvent, IFileSystemProviderCapabilitiesChangeEvent, IFileSystemProviderRegistrationEvent, IReadFileOptions, IReadFileStreamOptions, IResolveFileOptions, IFileStatResult, IFileStatResultWithMetadata, IResolveMetadataFileOptions, IFileStatWithPartialMetadata, IWriteFileOptions, IWatchOptionsWithCorrelation, IFileSystemWatcher, IWatchOptionsWithoutCorrelation } from "vscode/vscode/vs/platform/files/common/files";
+import { IFileService } from "vscode/vscode/vs/platform/files/common/files.service";
+import { ILogService } from "vscode/vscode/vs/platform/log/common/log.service";
+export declare function mkdirp(providerExtUri: IExtUri, provider: IFileSystemProvider, directory: URI): Promise<void>;
+export declare class FileService extends Disposable implements IFileService {
+    private readonly logService;
+    readonly _serviceBrand: undefined;
+    private readonly BUFFER_SIZE;
+    constructor(logService: ILogService);
+    private readonly _onDidChangeFileSystemProviderRegistrations;
+    readonly onDidChangeFileSystemProviderRegistrations: import("vscode/vscode/vs/base/common/event").Event<IFileSystemProviderRegistrationEvent>;
+    private readonly _onWillActivateFileSystemProvider;
+    readonly onWillActivateFileSystemProvider: import("vscode/vscode/vs/base/common/event").Event<IFileSystemProviderActivationEvent>;
+    private readonly _onDidChangeFileSystemProviderCapabilities;
+    readonly onDidChangeFileSystemProviderCapabilities: import("vscode/vscode/vs/base/common/event").Event<IFileSystemProviderCapabilitiesChangeEvent>;
+    private readonly provider;
+    registerProvider(scheme: string, provider: IFileSystemProvider): IDisposable;
+    getProvider(scheme: string): IFileSystemProvider | undefined;
+    activateProvider(scheme: string): Promise<void>;
+    canHandleResource(resource: URI): Promise<boolean>;
+    hasProvider(resource: URI): boolean;
+    hasCapability(resource: URI, capability: FileSystemProviderCapabilities): boolean;
+    listCapabilities(): Iterable<{
+        scheme: string;
+        capabilities: FileSystemProviderCapabilities;
+    }>;
+    protected withProvider(resource: URI): Promise<IFileSystemProvider>;
+    private withReadProvider;
+    private withWriteProvider;
+    private readonly _onDidRunOperation;
+    readonly onDidRunOperation: import("vscode/vscode/vs/base/common/event").Event<FileOperationEvent>;
+    resolve(resource: URI, options: IResolveMetadataFileOptions): Promise<IFileStatWithMetadata>;
+    resolve(resource: URI, options?: IResolveFileOptions): Promise<IFileStat>;
+    private doResolveFile;
+    private toFileStat;
+    resolveAll(toResolve: {
+        resource: URI;
+        options?: IResolveFileOptions;
+    }[]): Promise<IFileStatResult[]>;
+    resolveAll(toResolve: {
+        resource: URI;
+        options: IResolveMetadataFileOptions;
+    }[]): Promise<IFileStatResultWithMetadata[]>;
+    stat(resource: URI): Promise<IFileStatWithPartialMetadata>;
+    exists(resource: URI): Promise<boolean>;
+    canCreateFile(resource: URI, options?: ICreateFileOptions): Promise<Error | true>;
+    private doValidateCreateFile;
+    createFile(resource: URI, bufferOrReadableOrStream?: VSBuffer | VSBufferReadable | VSBufferReadableStream, options?: ICreateFileOptions): Promise<IFileStatWithMetadata>;
+    writeFile(resource: URI, bufferOrReadableOrStream: VSBuffer | VSBufferReadable | VSBufferReadableStream, options?: IWriteFileOptions): Promise<IFileStatWithMetadata>;
+    private validateWriteFile;
+    readFile(resource: URI, options?: IReadFileOptions, token?: CancellationToken): Promise<IFileContent>;
+    private doReadFileAtomic;
+    private doReadFile;
+    readFileStream(resource: URI, options?: IReadFileStreamOptions, token?: CancellationToken): Promise<IFileStreamContent>;
+    private doReadFileStream;
+    private restoreReadError;
+    private readFileStreamed;
+    private readFileBuffered;
+    private readFileUnbuffered;
+    private validateReadFile;
+    private validateReadFileLimits;
+    canMove(source: URI, target: URI, overwrite?: boolean): Promise<Error | true>;
+    canCopy(source: URI, target: URI, overwrite?: boolean): Promise<Error | true>;
+    private doCanMoveCopy;
+    move(source: URI, target: URI, overwrite?: boolean): Promise<IFileStatWithMetadata>;
+    copy(source: URI, target: URI, overwrite?: boolean): Promise<IFileStatWithMetadata>;
+    private doMoveCopy;
+    private doCopyFile;
+    private doCopyFolder;
+    private doValidateMoveCopy;
+    private getExtUri;
+    private isPathCaseSensitive;
+    createFolder(resource: URI): Promise<IFileStatWithMetadata>;
+    private mkdirp;
+    canDelete(resource: URI, options?: Partial<IFileDeleteOptions>): Promise<Error | true>;
+    private doValidateDelete;
+    del(resource: URI, options?: Partial<IFileDeleteOptions>): Promise<void>;
+    cloneFile(source: URI, target: URI): Promise<void>;
+    private readonly internalOnDidFilesChange;
+    private readonly _onDidUncorrelatedFilesChange;
+    readonly onDidFilesChange: import("vscode/vscode/vs/base/common/event").Event<FileChangesEvent>;
+    private readonly _onDidWatchError;
+    readonly onDidWatchError: import("vscode/vscode/vs/base/common/event").Event<Error>;
+    private readonly activeWatchers;
+    private static WATCHER_CORRELATION_IDS;
+    createWatcher(resource: URI, options: IWatchOptionsWithoutCorrelation): IFileSystemWatcher;
+    watch(resource: URI, options: IWatchOptionsWithCorrelation): IFileSystemWatcher;
+    watch(resource: URI, options?: IWatchOptionsWithoutCorrelation): IDisposable;
+    private doWatch;
+    dispose(): void;
+    private readonly writeQueue;
+    private doWriteBuffered;
+    private doWriteStreamBufferedQueued;
+    private doWriteReadableBufferedQueued;
+    private doWriteBuffer;
+    private doWriteUnbuffered;
+    private doWriteUnbufferedQueued;
+    private doPipeBuffered;
+    private doPipeBufferedQueued;
+    private doPipeUnbuffered;
+    private doPipeUnbufferedQueued;
+    private doPipeUnbufferedToBuffered;
+    private doPipeUnbufferedToBufferedQueued;
+    private doPipeBufferedToUnbuffered;
+    protected throwIfFileSystemIsReadonly<T extends IFileSystemProvider>(provider: T, resource: URI): T;
+    private throwIfFileIsReadonly;
+    private resourceForError;
+}