@theia/filesystem 1.45.1 → 1.46.0-next.72

package/lib/common/io.js

@@ -1,111 +1,111 @@
-"use strict";
-// *****************************************************************************
-// Copyright (C) 2020 TypeFox and others.
-//
-// This program and the accompanying materials are made available under the
-// terms of the Eclipse Public License v. 2.0 which is available at
-// http://www.eclipse.org/legal/epl-2.0.
-//
-// This Source Code may also be made available under the following Secondary
-// Licenses when the conditions for such availability set forth in the Eclipse
-// Public License v. 2.0 are satisfied: GNU General Public License, version 2
-// with the GNU Classpath Exception which is available at
-// https://www.gnu.org/software/classpath/license.html.
-//
-// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
-// *****************************************************************************
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-// based on https://github.com/microsoft/vscode/blob/04c36be045a94fee58e5f8992d3e3fd980294a84/src/vs/platform/files/common/io.ts
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.readFileIntoStream = void 0;
-const buffer_1 = require("@theia/core/lib/common//buffer");
-const cancellation_1 = require("@theia/core/lib/common/cancellation");
-const files_1 = require("./files");
-/**
- * A helper to read a file from a provider with open/read/close capability into a stream.
- */
-async function readFileIntoStream(provider, resource, target, transformer, options, token) {
-    let error = undefined;
-    try {
-        await doReadFileIntoStream(provider, resource, target, transformer, options, token);
-    }
-    catch (err) {
-        error = err;
-    }
-    finally {
-        if (error && options.errorTransformer) {
-            error = options.errorTransformer(error);
-        }
-        target.end(error);
-    }
-}
-exports.readFileIntoStream = readFileIntoStream;
-async function doReadFileIntoStream(provider, resource, target, transformer, options, token) {
-    // Check for cancellation
-    throwIfCancelled(token);
-    // open handle through provider
-    const handle = await provider.open(resource, { create: false });
-    // Check for cancellation
-    throwIfCancelled(token);
-    try {
-        let totalBytesRead = 0;
-        let bytesRead = 0;
-        let allowedRemainingBytes = (options && typeof options.length === 'number') ? options.length : undefined;
-        let buffer = buffer_1.BinaryBuffer.alloc(Math.min(options.bufferSize, typeof allowedRemainingBytes === 'number' ? allowedRemainingBytes : options.bufferSize));
-        let posInFile = options && typeof options.position === 'number' ? options.position : 0;
-        let posInBuffer = 0;
-        do {
-            // read from source (handle) at current position (pos) into buffer (buffer) at
-            // buffer position (posInBuffer) up to the size of the buffer (buffer.byteLength).
-            bytesRead = await provider.read(handle, posInFile, buffer.buffer, posInBuffer, buffer.byteLength - posInBuffer);
-            posInFile += bytesRead;
-            posInBuffer += bytesRead;
-            totalBytesRead += bytesRead;
-            if (typeof allowedRemainingBytes === 'number') {
-                allowedRemainingBytes -= bytesRead;
-            }
-            // when buffer full, create a new one and emit it through stream
-            if (posInBuffer === buffer.byteLength) {
-                await target.write(transformer(buffer));
-                buffer = buffer_1.BinaryBuffer.alloc(Math.min(options.bufferSize, typeof allowedRemainingBytes === 'number' ? allowedRemainingBytes : options.bufferSize));
-                posInBuffer = 0;
-            }
-        } while (bytesRead > 0 && (typeof allowedRemainingBytes !== 'number' || allowedRemainingBytes > 0) && throwIfCancelled(token) && throwIfTooLarge(totalBytesRead, options));
-        // wrap up with last buffer (also respect maxBytes if provided)
-        if (posInBuffer > 0) {
-            let lastChunkLength = posInBuffer;
-            if (typeof allowedRemainingBytes === 'number') {
-                lastChunkLength = Math.min(posInBuffer, allowedRemainingBytes);
-            }
-            target.write(transformer(buffer.slice(0, lastChunkLength)));
-        }
-    }
-    catch (error) {
-        throw (0, files_1.ensureFileSystemProviderError)(error);
-    }
-    finally {
-        await provider.close(handle);
-    }
-}
-function throwIfCancelled(token) {
-    if (token.isCancellationRequested) {
-        throw (0, cancellation_1.cancelled)();
-    }
-    return true;
-}
-function throwIfTooLarge(totalBytesRead, options) {
-    // Return early if file is too large to load and we have configured limits
-    if (options === null || options === void 0 ? void 0 : options.limits) {
-        if (typeof options.limits.memory === 'number' && totalBytesRead > options.limits.memory) {
-            throw (0, files_1.createFileSystemProviderError)('To open a file of this size, you need to restart and allow it to use more memory', files_1.FileSystemProviderErrorCode.FileExceedsMemoryLimit);
-        }
-        if (typeof options.limits.size === 'number' && totalBytesRead > options.limits.size) {
-            throw (0, files_1.createFileSystemProviderError)('File is too large to open', files_1.FileSystemProviderErrorCode.FileTooLarge);
-        }
-    }
-    return true;
-}
+"use strict";
+// *****************************************************************************
+// Copyright (C) 2020 TypeFox and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+// based on https://github.com/microsoft/vscode/blob/04c36be045a94fee58e5f8992d3e3fd980294a84/src/vs/platform/files/common/io.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readFileIntoStream = void 0;
+const buffer_1 = require("@theia/core/lib/common//buffer");
+const cancellation_1 = require("@theia/core/lib/common/cancellation");
+const files_1 = require("./files");
+/**
+ * A helper to read a file from a provider with open/read/close capability into a stream.
+ */
+async function readFileIntoStream(provider, resource, target, transformer, options, token) {
+    let error = undefined;
+    try {
+        await doReadFileIntoStream(provider, resource, target, transformer, options, token);
+    }
+    catch (err) {
+        error = err;
+    }
+    finally {
+        if (error && options.errorTransformer) {
+            error = options.errorTransformer(error);
+        }
+        target.end(error);
+    }
+}
+exports.readFileIntoStream = readFileIntoStream;
+async function doReadFileIntoStream(provider, resource, target, transformer, options, token) {
+    // Check for cancellation
+    throwIfCancelled(token);
+    // open handle through provider
+    const handle = await provider.open(resource, { create: false });
+    // Check for cancellation
+    throwIfCancelled(token);
+    try {
+        let totalBytesRead = 0;
+        let bytesRead = 0;
+        let allowedRemainingBytes = (options && typeof options.length === 'number') ? options.length : undefined;
+        let buffer = buffer_1.BinaryBuffer.alloc(Math.min(options.bufferSize, typeof allowedRemainingBytes === 'number' ? allowedRemainingBytes : options.bufferSize));
+        let posInFile = options && typeof options.position === 'number' ? options.position : 0;
+        let posInBuffer = 0;
+        do {
+            // read from source (handle) at current position (pos) into buffer (buffer) at
+            // buffer position (posInBuffer) up to the size of the buffer (buffer.byteLength).
+            bytesRead = await provider.read(handle, posInFile, buffer.buffer, posInBuffer, buffer.byteLength - posInBuffer);
+            posInFile += bytesRead;
+            posInBuffer += bytesRead;
+            totalBytesRead += bytesRead;
+            if (typeof allowedRemainingBytes === 'number') {
+                allowedRemainingBytes -= bytesRead;
+            }
+            // when buffer full, create a new one and emit it through stream
+            if (posInBuffer === buffer.byteLength) {
+                await target.write(transformer(buffer));
+                buffer = buffer_1.BinaryBuffer.alloc(Math.min(options.bufferSize, typeof allowedRemainingBytes === 'number' ? allowedRemainingBytes : options.bufferSize));
+                posInBuffer = 0;
+            }
+        } while (bytesRead > 0 && (typeof allowedRemainingBytes !== 'number' || allowedRemainingBytes > 0) && throwIfCancelled(token) && throwIfTooLarge(totalBytesRead, options));
+        // wrap up with last buffer (also respect maxBytes if provided)
+        if (posInBuffer > 0) {
+            let lastChunkLength = posInBuffer;
+            if (typeof allowedRemainingBytes === 'number') {
+                lastChunkLength = Math.min(posInBuffer, allowedRemainingBytes);
+            }
+            target.write(transformer(buffer.slice(0, lastChunkLength)));
+        }
+    }
+    catch (error) {
+        throw (0, files_1.ensureFileSystemProviderError)(error);
+    }
+    finally {
+        await provider.close(handle);
+    }
+}
+function throwIfCancelled(token) {
+    if (token.isCancellationRequested) {
+        throw (0, cancellation_1.cancelled)();
+    }
+    return true;
+}
+function throwIfTooLarge(totalBytesRead, options) {
+    // Return early if file is too large to load and we have configured limits
+    if (options === null || options === void 0 ? void 0 : options.limits) {
+        if (typeof options.limits.memory === 'number' && totalBytesRead > options.limits.memory) {
+            throw (0, files_1.createFileSystemProviderError)('To open a file of this size, you need to restart and allow it to use more memory', files_1.FileSystemProviderErrorCode.FileExceedsMemoryLimit);
+        }
+        if (typeof options.limits.size === 'number' && totalBytesRead > options.limits.size) {
+            throw (0, files_1.createFileSystemProviderError)('File is too large to open', files_1.FileSystemProviderErrorCode.FileTooLarge);
+        }
+    }
+    return true;
+}
 //# sourceMappingURL=io.js.map

package/lib/common/remote-file-system-provider.d.ts

@@ -1,165 +1,165 @@
-import URI from '@theia/core/lib/common/uri';
-import { Disposable, DisposableCollection } from '@theia/core/lib/common/disposable';
-import { FileWriteOptions, FileOpenOptions, FileChangeType, FileSystemProviderCapabilities, FileChange, Stat, FileOverwriteOptions, WatchOptions, FileType, FileSystemProvider, FileDeleteOptions, FileSystemProviderErrorCode, FileUpdateOptions, FileUpdateResult, FileReadStreamOptions } from './files';
-import { RpcServer, RpcProxy, RpcProxyFactory } from '@theia/core/lib/common/messaging/proxy-factory';
-import { ApplicationError } from '@theia/core/lib/common/application-error';
-import { Deferred } from '@theia/core/lib/common/promise-util';
-import type { TextDocumentContentChangeEvent } from '@theia/core/shared/vscode-languageserver-protocol';
-import { ReadableStreamEvents } from '@theia/core/lib/common/stream';
-import { CancellationToken } from '@theia/core/lib/common/cancellation';
-export declare const remoteFileSystemPath = "/services/remote-filesystem";
-export declare const RemoteFileSystemServer: unique symbol;
-export interface RemoteFileSystemServer extends RpcServer<RemoteFileSystemClient> {
-    getCapabilities(): Promise<FileSystemProviderCapabilities>;
-    stat(resource: string): Promise<Stat>;
-    access(resource: string, mode?: number): Promise<void>;
-    fsPath(resource: string): Promise<string>;
-    open(resource: string, opts: FileOpenOptions): Promise<number>;
-    close(fd: number): Promise<void>;
-    read(fd: number, pos: number, length: number): Promise<{
-        bytes: Uint8Array;
-        bytesRead: number;
-    }>;
-    readFileStream(resource: string, opts: FileReadStreamOptions, token: CancellationToken): Promise<number>;
-    readFile(resource: string): Promise<Uint8Array>;
-    write(fd: number, pos: number, data: Uint8Array, offset: number, length: number): Promise<number>;
-    writeFile(resource: string, content: Uint8Array, opts: FileWriteOptions): Promise<void>;
-    delete(resource: string, opts: FileDeleteOptions): Promise<void>;
-    mkdir(resource: string): Promise<void>;
-    readdir(resource: string): Promise<[string, FileType][]>;
-    rename(source: string, target: string, opts: FileOverwriteOptions): Promise<void>;
-    copy(source: string, target: string, opts: FileOverwriteOptions): Promise<void>;
-    watch(watcher: number, resource: string, opts: WatchOptions): Promise<void>;
-    unwatch(watcher: number): Promise<void>;
-    updateFile(resource: string, changes: TextDocumentContentChangeEvent[], opts: FileUpdateOptions): Promise<FileUpdateResult>;
-}
-export interface RemoteFileChange {
-    readonly type: FileChangeType;
-    readonly resource: string;
-}
-export interface RemoteFileStreamError extends Error {
-    code?: FileSystemProviderErrorCode;
-}
-export interface RemoteFileSystemClient {
-    notifyDidChangeFile(event: {
-        changes: RemoteFileChange[];
-    }): void;
-    notifyFileWatchError(): void;
-    notifyDidChangeCapabilities(capabilities: FileSystemProviderCapabilities): void;
-    onFileStreamData(handle: number, data: Uint8Array): void;
-    onFileStreamEnd(handle: number, error: RemoteFileStreamError | undefined): void;
-}
-export declare const RemoteFileSystemProviderError: ApplicationError.Constructor<-33005, {
-    code: FileSystemProviderErrorCode;
-    name: string;
-}>;
-export declare class RemoteFileSystemProxyFactory<T extends object> extends RpcProxyFactory<T> {
-    protected serializeError(e: any): any;
-    protected deserializeError(capturedError: Error, e: any): any;
-}
-/**
- * Frontend component.
- *
- * Wraps the remote filesystem provider living on the backend.
- */
-export declare class RemoteFileSystemProvider implements Required<FileSystemProvider>, Disposable {
-    private readonly onDidChangeFileEmitter;
-    readonly onDidChangeFile: import("@theia/core/lib/common/event").Event<readonly FileChange[]>;
-    private readonly onFileWatchErrorEmitter;
-    readonly onFileWatchError: import("@theia/core/lib/common/event").Event<void>;
-    private readonly onDidChangeCapabilitiesEmitter;
-    readonly onDidChangeCapabilities: import("@theia/core/lib/common/event").Event<void>;
-    private readonly onFileStreamDataEmitter;
-    private readonly onFileStreamData;
-    private readonly onFileStreamEndEmitter;
-    private readonly onFileStreamEnd;
-    protected readonly toDispose: DisposableCollection;
-    protected watcherSequence: number;
-    /**
-     * We'll track the currently allocated watchers, in order to re-allocate them
-     * with the same options once we reconnect to the backend after a disconnection.
-     */
-    protected readonly watchOptions: Map<number, {
-        uri: string;
-        options: WatchOptions;
-    }>;
-    private _capabilities;
-    get capabilities(): FileSystemProviderCapabilities;
-    protected readonly readyDeferred: Deferred<void>;
-    readonly ready: Promise<void>;
-    /**
-     * Wrapped remote filesystem.
-     */
-    protected readonly server: RpcProxy<RemoteFileSystemServer>;
-    protected init(): void;
-    dispose(): void;
-    protected setCapabilities(capabilities: FileSystemProviderCapabilities): void;
-    stat(resource: URI): Promise<Stat>;
-    access(resource: URI, mode?: number): Promise<void>;
-    fsPath(resource: URI): Promise<string>;
-    open(resource: URI, opts: FileOpenOptions): Promise<number>;
-    close(fd: number): Promise<void>;
-    read(fd: number, pos: number, data: Uint8Array, offset: number, length: number): Promise<number>;
-    readFile(resource: URI): Promise<Uint8Array>;
-    readFileStream(resource: URI, opts: FileReadStreamOptions, token: CancellationToken): ReadableStreamEvents<Uint8Array>;
-    write(fd: number, pos: number, data: Uint8Array, offset: number, length: number): Promise<number>;
-    writeFile(resource: URI, content: Uint8Array, opts: FileWriteOptions): Promise<void>;
-    delete(resource: URI, opts: FileDeleteOptions): Promise<void>;
-    mkdir(resource: URI): Promise<void>;
-    readdir(resource: URI): Promise<[string, FileType][]>;
-    rename(resource: URI, target: URI, opts: FileOverwriteOptions): Promise<void>;
-    copy(resource: URI, target: URI, opts: FileOverwriteOptions): Promise<void>;
-    updateFile(resource: URI, changes: TextDocumentContentChangeEvent[], opts: FileUpdateOptions): Promise<FileUpdateResult>;
-    watch(resource: URI, options: WatchOptions): Disposable;
-    /**
-     * When a frontend disconnects (e.g. bad connection) the backend resources will be cleared.
-     *
-     * This means that we need to re-allocate the watchers when a frontend reconnects.
-     */
-    protected reconnect(): void;
-}
-/**
- * Backend component.
- *
- * JSON-RPC server exposing a wrapped file system provider remotely.
- */
-export declare class FileSystemProviderServer implements RemoteFileSystemServer {
-    private readonly BUFFER_SIZE;
-    /**
-     * Mapping of `watcherId` to a disposable watcher handle.
-     */
-    protected watchers: Map<number, Disposable>;
-    protected readonly toDispose: DisposableCollection;
-    dispose(): void;
-    protected client: RemoteFileSystemClient | undefined;
-    setClient(client: RemoteFileSystemClient | undefined): void;
-    /**
-     * Wrapped file system provider.
-     */
-    protected readonly provider: FileSystemProvider & Partial<Disposable>;
-    protected init(): void;
-    getCapabilities(): Promise<FileSystemProviderCapabilities>;
-    stat(resource: string): Promise<Stat>;
-    access(resource: string, mode?: number): Promise<void>;
-    fsPath(resource: string): Promise<string>;
-    open(resource: string, opts: FileOpenOptions): Promise<number>;
-    close(fd: number): Promise<void>;
-    read(fd: number, pos: number, length: number): Promise<{
-        bytes: Uint8Array;
-        bytesRead: number;
-    }>;
-    write(fd: number, pos: number, data: Uint8Array, offset: number, length: number): Promise<number>;
-    readFile(resource: string): Promise<Uint8Array>;
-    writeFile(resource: string, content: Uint8Array, opts: FileWriteOptions): Promise<void>;
-    delete(resource: string, opts: FileDeleteOptions): Promise<void>;
-    mkdir(resource: string): Promise<void>;
-    readdir(resource: string): Promise<[string, FileType][]>;
-    rename(source: string, target: string, opts: FileOverwriteOptions): Promise<void>;
-    copy(source: string, target: string, opts: FileOverwriteOptions): Promise<void>;
-    updateFile(resource: string, changes: TextDocumentContentChangeEvent[], opts: FileUpdateOptions): Promise<FileUpdateResult>;
-    watch(requestedWatcherId: number, resource: string, opts: WatchOptions): Promise<void>;
-    unwatch(watcherId: number): Promise<void>;
-    protected readFileStreamSeq: number;
-    readFileStream(resource: string, opts: FileReadStreamOptions, token: CancellationToken): Promise<number>;
-}
+import URI from '@theia/core/lib/common/uri';
+import { Disposable, DisposableCollection } from '@theia/core/lib/common/disposable';
+import { FileWriteOptions, FileOpenOptions, FileChangeType, FileSystemProviderCapabilities, FileChange, Stat, FileOverwriteOptions, WatchOptions, FileType, FileSystemProvider, FileDeleteOptions, FileSystemProviderErrorCode, FileUpdateOptions, FileUpdateResult, FileReadStreamOptions } from './files';
+import { RpcServer, RpcProxy, RpcProxyFactory } from '@theia/core/lib/common/messaging/proxy-factory';
+import { ApplicationError } from '@theia/core/lib/common/application-error';
+import { Deferred } from '@theia/core/lib/common/promise-util';
+import type { TextDocumentContentChangeEvent } from '@theia/core/shared/vscode-languageserver-protocol';
+import { ReadableStreamEvents } from '@theia/core/lib/common/stream';
+import { CancellationToken } from '@theia/core/lib/common/cancellation';
+export declare const remoteFileSystemPath = "/services/remote-filesystem";
+export declare const RemoteFileSystemServer: unique symbol;
+export interface RemoteFileSystemServer extends RpcServer<RemoteFileSystemClient> {
+    getCapabilities(): Promise<FileSystemProviderCapabilities>;
+    stat(resource: string): Promise<Stat>;
+    access(resource: string, mode?: number): Promise<void>;
+    fsPath(resource: string): Promise<string>;
+    open(resource: string, opts: FileOpenOptions): Promise<number>;
+    close(fd: number): Promise<void>;
+    read(fd: number, pos: number, length: number): Promise<{
+        bytes: Uint8Array;
+        bytesRead: number;
+    }>;
+    readFileStream(resource: string, opts: FileReadStreamOptions, token: CancellationToken): Promise<number>;
+    readFile(resource: string): Promise<Uint8Array>;
+    write(fd: number, pos: number, data: Uint8Array, offset: number, length: number): Promise<number>;
+    writeFile(resource: string, content: Uint8Array, opts: FileWriteOptions): Promise<void>;
+    delete(resource: string, opts: FileDeleteOptions): Promise<void>;
+    mkdir(resource: string): Promise<void>;
+    readdir(resource: string): Promise<[string, FileType][]>;
+    rename(source: string, target: string, opts: FileOverwriteOptions): Promise<void>;
+    copy(source: string, target: string, opts: FileOverwriteOptions): Promise<void>;
+    watch(watcher: number, resource: string, opts: WatchOptions): Promise<void>;
+    unwatch(watcher: number): Promise<void>;
+    updateFile(resource: string, changes: TextDocumentContentChangeEvent[], opts: FileUpdateOptions): Promise<FileUpdateResult>;
+}
+export interface RemoteFileChange {
+    readonly type: FileChangeType;
+    readonly resource: string;
+}
+export interface RemoteFileStreamError extends Error {
+    code?: FileSystemProviderErrorCode;
+}
+export interface RemoteFileSystemClient {
+    notifyDidChangeFile(event: {
+        changes: RemoteFileChange[];
+    }): void;
+    notifyFileWatchError(): void;
+    notifyDidChangeCapabilities(capabilities: FileSystemProviderCapabilities): void;
+    onFileStreamData(handle: number, data: Uint8Array): void;
+    onFileStreamEnd(handle: number, error: RemoteFileStreamError | undefined): void;
+}
+export declare const RemoteFileSystemProviderError: ApplicationError.Constructor<-33005, {
+    code: FileSystemProviderErrorCode;
+    name: string;
+}>;
+export declare class RemoteFileSystemProxyFactory<T extends object> extends RpcProxyFactory<T> {
+    protected serializeError(e: any): any;
+    protected deserializeError(capturedError: Error, e: any): any;
+}
+/**
+ * Frontend component.
+ *
+ * Wraps the remote filesystem provider living on the backend.
+ */
+export declare class RemoteFileSystemProvider implements Required<FileSystemProvider>, Disposable {
+    private readonly onDidChangeFileEmitter;
+    readonly onDidChangeFile: import("@theia/core/lib/common/event").Event<readonly FileChange[]>;
+    private readonly onFileWatchErrorEmitter;
+    readonly onFileWatchError: import("@theia/core/lib/common/event").Event<void>;
+    private readonly onDidChangeCapabilitiesEmitter;
+    readonly onDidChangeCapabilities: import("@theia/core/lib/common/event").Event<void>;
+    private readonly onFileStreamDataEmitter;
+    private readonly onFileStreamData;
+    private readonly onFileStreamEndEmitter;
+    private readonly onFileStreamEnd;
+    protected readonly toDispose: DisposableCollection;
+    protected watcherSequence: number;
+    /**
+     * We'll track the currently allocated watchers, in order to re-allocate them
+     * with the same options once we reconnect to the backend after a disconnection.
+     */
+    protected readonly watchOptions: Map<number, {
+        uri: string;
+        options: WatchOptions;
+    }>;
+    private _capabilities;
+    get capabilities(): FileSystemProviderCapabilities;
+    protected readonly readyDeferred: Deferred<void>;
+    readonly ready: Promise<void>;
+    /**
+     * Wrapped remote filesystem.
+     */
+    protected readonly server: RpcProxy<RemoteFileSystemServer>;
+    protected init(): void;
+    dispose(): void;
+    protected setCapabilities(capabilities: FileSystemProviderCapabilities): void;
+    stat(resource: URI): Promise<Stat>;
+    access(resource: URI, mode?: number): Promise<void>;
+    fsPath(resource: URI): Promise<string>;
+    open(resource: URI, opts: FileOpenOptions): Promise<number>;
+    close(fd: number): Promise<void>;
+    read(fd: number, pos: number, data: Uint8Array, offset: number, length: number): Promise<number>;
+    readFile(resource: URI): Promise<Uint8Array>;
+    readFileStream(resource: URI, opts: FileReadStreamOptions, token: CancellationToken): ReadableStreamEvents<Uint8Array>;
+    write(fd: number, pos: number, data: Uint8Array, offset: number, length: number): Promise<number>;
+    writeFile(resource: URI, content: Uint8Array, opts: FileWriteOptions): Promise<void>;
+    delete(resource: URI, opts: FileDeleteOptions): Promise<void>;
+    mkdir(resource: URI): Promise<void>;
+    readdir(resource: URI): Promise<[string, FileType][]>;
+    rename(resource: URI, target: URI, opts: FileOverwriteOptions): Promise<void>;
+    copy(resource: URI, target: URI, opts: FileOverwriteOptions): Promise<void>;
+    updateFile(resource: URI, changes: TextDocumentContentChangeEvent[], opts: FileUpdateOptions): Promise<FileUpdateResult>;
+    watch(resource: URI, options: WatchOptions): Disposable;
+    /**
+     * When a frontend disconnects (e.g. bad connection) the backend resources will be cleared.
+     *
+     * This means that we need to re-allocate the watchers when a frontend reconnects.
+     */
+    protected reconnect(): void;
+}
+/**
+ * Backend component.
+ *
+ * JSON-RPC server exposing a wrapped file system provider remotely.
+ */
+export declare class FileSystemProviderServer implements RemoteFileSystemServer {
+    private readonly BUFFER_SIZE;
+    /**
+     * Mapping of `watcherId` to a disposable watcher handle.
+     */
+    protected watchers: Map<number, Disposable>;
+    protected readonly toDispose: DisposableCollection;
+    dispose(): void;
+    protected client: RemoteFileSystemClient | undefined;
+    setClient(client: RemoteFileSystemClient | undefined): void;
+    /**
+     * Wrapped file system provider.
+     */
+    protected readonly provider: FileSystemProvider & Partial<Disposable>;
+    protected init(): void;
+    getCapabilities(): Promise<FileSystemProviderCapabilities>;
+    stat(resource: string): Promise<Stat>;
+    access(resource: string, mode?: number): Promise<void>;
+    fsPath(resource: string): Promise<string>;
+    open(resource: string, opts: FileOpenOptions): Promise<number>;
+    close(fd: number): Promise<void>;
+    read(fd: number, pos: number, length: number): Promise<{
+        bytes: Uint8Array;
+        bytesRead: number;
+    }>;
+    write(fd: number, pos: number, data: Uint8Array, offset: number, length: number): Promise<number>;
+    readFile(resource: string): Promise<Uint8Array>;
+    writeFile(resource: string, content: Uint8Array, opts: FileWriteOptions): Promise<void>;
+    delete(resource: string, opts: FileDeleteOptions): Promise<void>;
+    mkdir(resource: string): Promise<void>;
+    readdir(resource: string): Promise<[string, FileType][]>;
+    rename(source: string, target: string, opts: FileOverwriteOptions): Promise<void>;
+    copy(source: string, target: string, opts: FileOverwriteOptions): Promise<void>;
+    updateFile(resource: string, changes: TextDocumentContentChangeEvent[], opts: FileUpdateOptions): Promise<FileUpdateResult>;
+    watch(requestedWatcherId: number, resource: string, opts: WatchOptions): Promise<void>;
+    unwatch(watcherId: number): Promise<void>;
+    protected readFileStreamSeq: number;
+    readFileStream(resource: string, opts: FileReadStreamOptions, token: CancellationToken): Promise<number>;
+}
 //# sourceMappingURL=remote-file-system-provider.d.ts.map