@codingame/monaco-vscode-api 1.78.8 → 1.79.0

package/dist/files.d.ts

@@ -0,0 +1,853 @@
+import { S as ServiceIdentifier } from './instantiation.js';
+import { E as Event, I as IDisposable, C as CancellationToken } from './event.js';
+import { U as URI } from './uri.js';
+
+interface IRelativePattern {
+    /**
+     * A base file path to which this pattern will be matched against relatively.
+     */
+    readonly base: string;
+    /**
+     * A file glob pattern like `*.{ts,js}` that will be matched on file paths
+     * relative to the base path.
+     *
+     * Example: Given a base of `/home/work/folder` and a file path of `/home/work/folder/index.js`,
+     * the file glob pattern will match on `index.js`.
+     */
+    readonly pattern: string;
+}
+
+interface ReadableStreamEvents<T> {
+    /**
+     * The 'data' event is emitted whenever the stream is
+     * relinquishing ownership of a chunk of data to a consumer.
+     *
+     * NOTE: PLEASE UNDERSTAND THAT ADDING A DATA LISTENER CAN
+     * TURN THE STREAM INTO FLOWING MODE. IT IS THEREFOR THE
+     * LAST LISTENER THAT SHOULD BE ADDED AND NOT THE FIRST
+     *
+     * Use `listenStream` as a helper method to listen to
+     * stream events in the right order.
+     */
+    on(event: 'data', callback: (data: T) => void): void;
+    /**
+     * Emitted when any error occurs.
+     */
+    on(event: 'error', callback: (err: Error) => void): void;
+    /**
+     * The 'end' event is emitted when there is no more data
+     * to be consumed from the stream. The 'end' event will
+     * not be emitted unless the data is completely consumed.
+     */
+    on(event: 'end', callback: () => void): void;
+}
+/**
+ * A interface that emulates the API shape of a node.js readable
+ * stream for use in native and web environments.
+ */
+interface ReadableStream<T> extends ReadableStreamEvents<T> {
+    /**
+     * Stops emitting any events until resume() is called.
+     */
+    pause(): void;
+    /**
+     * Starts emitting events again after pause() was called.
+     */
+    resume(): void;
+    /**
+     * Destroys the stream and stops emitting any event.
+     */
+    destroy(): void;
+    /**
+     * Allows to remove a listener that was previously added.
+     */
+    removeListener(event: string, callback: Function): void;
+}
+/**
+ * A interface that emulates the API shape of a node.js readable
+ * for use in native and web environments.
+ */
+interface Readable<T> {
+    /**
+     * Read data from the underlying source. Will return
+     * null to indicate that no more data can be read.
+     */
+    read(): T | null;
+}
+
+declare class VSBuffer {
+    /**
+     * When running in a nodejs context, the backing store for the returned `VSBuffer` instance
+     * might use a nodejs Buffer allocated from node's Buffer pool, which is not transferrable.
+     */
+    static alloc(byteLength: number): VSBuffer;
+    /**
+     * When running in a nodejs context, if `actual` is not a nodejs Buffer, the backing store for
+     * the returned `VSBuffer` instance might use a nodejs Buffer allocated from node's Buffer pool,
+     * which is not transferrable.
+     */
+    static wrap(actual: Uint8Array): VSBuffer;
+    /**
+     * When running in a nodejs context, the backing store for the returned `VSBuffer` instance
+     * might use a nodejs Buffer allocated from node's Buffer pool, which is not transferrable.
+     */
+    static fromString(source: string, options?: {
+        dontUseNodeBuffer?: boolean;
+    }): VSBuffer;
+    /**
+     * When running in a nodejs context, the backing store for the returned `VSBuffer` instance
+     * might use a nodejs Buffer allocated from node's Buffer pool, which is not transferrable.
+     */
+    static fromByteArray(source: number[]): VSBuffer;
+    /**
+     * When running in a nodejs context, the backing store for the returned `VSBuffer` instance
+     * might use a nodejs Buffer allocated from node's Buffer pool, which is not transferrable.
+     */
+    static concat(buffers: VSBuffer[], totalLength?: number): VSBuffer;
+    readonly buffer: Uint8Array;
+    readonly byteLength: number;
+    private constructor();
+    /**
+     * When running in a nodejs context, the backing store for the returned `VSBuffer` instance
+     * might use a nodejs Buffer allocated from node's Buffer pool, which is not transferrable.
+     */
+    clone(): VSBuffer;
+    toString(): string;
+    slice(start?: number, end?: number): VSBuffer;
+    set(array: VSBuffer, offset?: number): void;
+    set(array: Uint8Array, offset?: number): void;
+    set(array: ArrayBuffer, offset?: number): void;
+    set(array: ArrayBufferView, offset?: number): void;
+    set(array: VSBuffer | Uint8Array | ArrayBuffer | ArrayBufferView, offset?: number): void;
+    readUInt32BE(offset: number): number;
+    writeUInt32BE(value: number, offset: number): void;
+    readUInt32LE(offset: number): number;
+    writeUInt32LE(value: number, offset: number): void;
+    readUInt8(offset: number): number;
+    writeUInt8(value: number, offset: number): void;
+}
+interface VSBufferReadable extends Readable<VSBuffer> {
+}
+interface VSBufferReadableStream extends ReadableStream<VSBuffer> {
+}
+
+declare const IFileService: ServiceIdentifier<IFileService>;
+interface IFileService {
+    readonly _serviceBrand: undefined;
+    /**
+     * An event that is fired when a file system provider is added or removed
+     */
+    readonly onDidChangeFileSystemProviderRegistrations: Event<IFileSystemProviderRegistrationEvent>;
+    /**
+     * An event that is fired when a registered file system provider changes its capabilities.
+     */
+    readonly onDidChangeFileSystemProviderCapabilities: Event<IFileSystemProviderCapabilitiesChangeEvent>;
+    /**
+     * An event that is fired when a file system provider is about to be activated. Listeners
+     * can join this event with a long running promise to help in the activation process.
+     */
+    readonly onWillActivateFileSystemProvider: Event<IFileSystemProviderActivationEvent>;
+    /**
+     * Registers a file system provider for a certain scheme.
+     */
+    registerProvider(scheme: string, provider: IFileSystemProvider): IDisposable;
+    /**
+     * Returns a file system provider for a certain scheme.
+     */
+    getProvider(scheme: string): IFileSystemProvider | undefined;
+    /**
+     * Tries to activate a provider with the given scheme.
+     */
+    activateProvider(scheme: string): Promise<void>;
+    /**
+     * Checks if this file service can handle the given resource by
+     * first activating any extension that wants to be activated
+     * on the provided resource scheme to include extensions that
+     * contribute file system providers for the given resource.
+     */
+    canHandleResource(resource: URI): Promise<boolean>;
+    /**
+     * Checks if the file service has a registered provider for the
+     * provided resource.
+     *
+     * Note: this does NOT account for contributed providers from
+     * extensions that have not been activated yet. To include those,
+     * consider to call `await fileService.canHandleResource(resource)`.
+     */
+    hasProvider(resource: URI): boolean;
+    /**
+     * Checks if the provider for the provided resource has the provided file system capability.
+     */
+    hasCapability(resource: URI, capability: FileSystemProviderCapabilities): boolean;
+    /**
+     * List the schemes and capabilities for registered file system providers
+     */
+    listCapabilities(): Iterable<{
+        scheme: string;
+        capabilities: FileSystemProviderCapabilities;
+    }>;
+    /**
+     * Allows to listen for file changes. The event will fire for every file within the opened workspace
+     * (if any) as well as all files that have been watched explicitly using the #watch() API.
+     */
+    readonly onDidFilesChange: Event<FileChangesEvent>;
+    /**
+     * An event that is fired upon successful completion of a certain file operation.
+     */
+    readonly onDidRunOperation: Event<FileOperationEvent>;
+    /**
+     * Resolve the properties of a file/folder identified by the resource. For a folder, children
+     * information is resolved as well depending on the provided options. Use `stat()` method if
+     * you do not need children information.
+     *
+     * If the optional parameter "resolveTo" is specified in options, the stat service is asked
+     * to provide a stat object that should contain the full graph of folders up to all of the
+     * target resources.
+     *
+     * If the optional parameter "resolveSingleChildDescendants" is specified in options,
+     * the stat service is asked to automatically resolve child folders that only
+     * contain a single element.
+     *
+     * If the optional parameter "resolveMetadata" is specified in options,
+     * the stat will contain metadata information such as size, mtime and etag.
+     */
+    resolve(resource: URI, options: IResolveMetadataFileOptions): Promise<IFileStatWithMetadata>;
+    resolve(resource: URI, options?: IResolveFileOptions): Promise<IFileStat>;
+    /**
+     * Same as `resolve()` but supports resolving multiple resources in parallel.
+     *
+     * If one of the resolve targets fails to resolve returns a fake `IFileStat` instead of
+     * making the whole call fail.
+     */
+    resolveAll(toResolve: {
+        resource: URI;
+        options: IResolveMetadataFileOptions;
+    }[]): Promise<IFileStatResult[]>;
+    resolveAll(toResolve: {
+        resource: URI;
+        options?: IResolveFileOptions;
+    }[]): Promise<IFileStatResult[]>;
+    /**
+     * Same as `resolve()` but without resolving the children of a folder if the
+     * resource is pointing to a folder.
+     */
+    stat(resource: URI): Promise<IFileStatWithPartialMetadata>;
+    /**
+     * Finds out if a file/folder identified by the resource exists.
+     */
+    exists(resource: URI): Promise<boolean>;
+    /**
+     * Read the contents of the provided resource unbuffered.
+     */
+    readFile(resource: URI, options?: IReadFileOptions, token?: CancellationToken): Promise<IFileContent>;
+    /**
+     * Read the contents of the provided resource buffered as stream.
+     */
+    readFileStream(resource: URI, options?: IReadFileStreamOptions, token?: CancellationToken): Promise<IFileStreamContent>;
+    /**
+     * Updates the content replacing its previous value.
+     *
+     * Emits a `FileOperation.WRITE` file operation event when successful.
+     */
+    writeFile(resource: URI, bufferOrReadableOrStream: VSBuffer | VSBufferReadable | VSBufferReadableStream, options?: IWriteFileOptions): Promise<IFileStatWithMetadata>;
+    /**
+     * Moves the file/folder to a new path identified by the resource.
+     *
+     * The optional parameter overwrite can be set to replace an existing file at the location.
+     *
+     * Emits a `FileOperation.MOVE` file operation event when successful.
+     */
+    move(source: URI, target: URI, overwrite?: boolean): Promise<IFileStatWithMetadata>;
+    /**
+     * Find out if a move operation is possible given the arguments. No changes on disk will
+     * be performed. Returns an Error if the operation cannot be done.
+     */
+    canMove(source: URI, target: URI, overwrite?: boolean): Promise<Error | true>;
+    /**
+     * Copies the file/folder to a path identified by the resource. A folder is copied
+     * recursively.
+     *
+     * Emits a `FileOperation.COPY` file operation event when successful.
+     */
+    copy(source: URI, target: URI, overwrite?: boolean): Promise<IFileStatWithMetadata>;
+    /**
+     * Find out if a copy operation is possible given the arguments. No changes on disk will
+     * be performed. Returns an Error if the operation cannot be done.
+     */
+    canCopy(source: URI, target: URI, overwrite?: boolean): Promise<Error | true>;
+    /**
+     * Clones a file to a path identified by the resource. Folders are not supported.
+     *
+     * If the target path exists, it will be overwritten.
+     */
+    cloneFile(source: URI, target: URI): Promise<void>;
+    /**
+     * Creates a new file with the given path and optional contents. The returned promise
+     * will have the stat model object as a result.
+     *
+     * The optional parameter content can be used as value to fill into the new file.
+     *
+     * Emits a `FileOperation.CREATE` file operation event when successful.
+     */
+    createFile(resource: URI, bufferOrReadableOrStream?: VSBuffer | VSBufferReadable | VSBufferReadableStream, options?: ICreateFileOptions): Promise<IFileStatWithMetadata>;
+    /**
+     * Find out if a file create operation is possible given the arguments. No changes on disk will
+     * be performed. Returns an Error if the operation cannot be done.
+     */
+    canCreateFile(resource: URI, options?: ICreateFileOptions): Promise<Error | true>;
+    /**
+     * Creates a new folder with the given path. The returned promise
+     * will have the stat model object as a result.
+     *
+     * Emits a `FileOperation.CREATE` file operation event when successful.
+     */
+    createFolder(resource: URI): Promise<IFileStatWithMetadata>;
+    /**
+     * Deletes the provided file. The optional useTrash parameter allows to
+     * move the file to trash. The optional recursive parameter allows to delete
+     * non-empty folders recursively.
+     *
+     * Emits a `FileOperation.DELETE` file operation event when successful.
+     */
+    del(resource: URI, options?: Partial<IFileDeleteOptions>): Promise<void>;
+    /**
+     * Find out if a delete operation is possible given the arguments. No changes on disk will
+     * be performed. Returns an Error if the operation cannot be done.
+     */
+    canDelete(resource: URI, options?: Partial<IFileDeleteOptions>): Promise<Error | true>;
+    /**
+     * An event that signals an error when watching for file changes.
+     */
+    readonly onDidWatchError: Event<Error>;
+    /**
+     * Allows to start a watcher that reports file/folder change events on the provided resource.
+     *
+     * Note: recursive file watching is not supported from this method. Only events from files
+     * that are direct children of the provided resource will be reported.
+     */
+    watch(resource: URI, options?: IWatchOptions): IDisposable;
+    /**
+     * Frees up any resources occupied by this service.
+     */
+    dispose(): void;
+}
+interface IFileOverwriteOptions {
+    /**
+     * Set to `true` to overwrite a file if it exists. Will
+     * throw an error otherwise if the file does exist.
+     */
+    readonly overwrite: boolean;
+}
+interface IFileUnlockOptions {
+    /**
+     * Set to `true` to try to remove any write locks the file might
+     * have. A file that is write locked will throw an error for any
+     * attempt to write to unless `unlock: true` is provided.
+     */
+    readonly unlock: boolean;
+}
+interface IFileReadLimits {
+    /**
+     * If the file exceeds the given size, an error of kind
+     * `FILE_TOO_LARGE` will be thrown.
+     */
+    size?: number;
+}
+interface IFileReadStreamOptions {
+    /**
+     * Is an integer specifying where to begin reading from in the file. If position is undefined,
+     * data will be read from the current file position.
+     */
+    readonly position?: number;
+    /**
+     * Is an integer specifying how many bytes to read from the file. By default, all bytes
+     * will be read.
+     */
+    readonly length?: number;
+    /**
+     * 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;
+}
+interface IFileWriteOptions extends IFileOverwriteOptions, IFileUnlockOptions {
+    /**
+     * Set to `true` to create a file when it does not exist. Will
+     * throw an error otherwise if the file does not exist.
+     */
+    readonly create: boolean;
+}
+type IFileOpenOptions = IFileOpenForReadOptions | IFileOpenForWriteOptions;
+interface IFileOpenForReadOptions {
+    /**
+     * A hint that the file should be opened for reading only.
+     */
+    readonly create: false;
+}
+interface IFileOpenForWriteOptions extends IFileUnlockOptions {
+    /**
+     * A hint that the file should be opened for reading and writing.
+     */
+    readonly create: true;
+}
+interface IFileDeleteOptions {
+    /**
+     * Set to `true` to recursively delete any children of the file. This
+     * only applies to folders and can lead to an error unless provided
+     * if the folder is not empty.
+     */
+    readonly recursive: boolean;
+    /**
+     * Set to `true` to attempt to move the file to trash
+     * instead of deleting it permanently from disk. This
+     * option maybe not be supported on all providers.
+     */
+    readonly useTrash: boolean;
+}
+declare enum FileType {
+    /**
+     * File is unknown (neither file, directory nor symbolic link).
+     */
+    Unknown = 0,
+    /**
+     * File is a normal file.
+     */
+    File = 1,
+    /**
+     * File is a directory.
+     */
+    Directory = 2,
+    /**
+     * File is a symbolic link.
+     *
+     * Note: even when the file is a symbolic link, you can test for
+     * `FileType.File` and `FileType.Directory` to know the type of
+     * the target the link points to.
+     */
+    SymbolicLink = 64
+}
+declare enum FilePermission {
+    /**
+     * File is readonly.
+     */
+    Readonly = 1
+}
+interface IStat {
+    /**
+     * The file type.
+     */
+    readonly type: FileType;
+    /**
+     * The last modification date represented as millis from unix epoch.
+     */
+    readonly mtime: number;
+    /**
+     * The creation date represented as millis from unix epoch.
+     */
+    readonly ctime: number;
+    /**
+     * The size of the file in bytes.
+     */
+    readonly size: number;
+    /**
+     * The file permissions.
+     */
+    readonly permissions?: FilePermission;
+}
+interface IWatchOptions {
+    /**
+     * Set to `true` to watch for changes recursively in a folder
+     * and all of its children.
+     */
+    readonly recursive: boolean;
+    /**
+     * A set of glob patterns or paths to exclude from watching.
+     * Paths can be relative or absolute and when relative are
+     * resolved against the watched folder. Glob patterns are
+     * always matched relative to the watched folder.
+     */
+    excludes: string[];
+    /**
+     * An optional set of glob patterns or paths to include for
+     * watching. If not provided, all paths are considered for
+     * events.
+     * Paths can be relative or absolute and when relative are
+     * resolved against the watched folder. Glob patterns are
+     * always matched relative to the watched folder.
+     */
+    includes?: Array<string | IRelativePattern>;
+}
+declare const enum FileSystemProviderCapabilities {
+    /**
+     * No capabilities.
+     */
+    None = 0,
+    /**
+     * Provider supports unbuffered read/write.
+     */
+    FileReadWrite = 2,
+    /**
+     * Provider supports open/read/write/close low level file operations.
+     */
+    FileOpenReadWriteClose = 4,
+    /**
+     * Provider supports stream based reading.
+     */
+    FileReadStream = 16,
+    /**
+     * Provider supports copy operation.
+     */
+    FileFolderCopy = 8,
+    /**
+     * Provider is path case sensitive.
+     */
+    PathCaseSensitive = 1024,
+    /**
+     * All files of the provider are readonly.
+     */
+    Readonly = 2048,
+    /**
+     * Provider supports to delete via trash.
+     */
+    Trash = 4096,
+    /**
+     * Provider support to unlock files for writing.
+     */
+    FileWriteUnlock = 8192,
+    /**
+     * Provider support to read files atomically. This implies the
+     * provider provides the `FileReadWrite` capability too.
+     */
+    FileAtomicRead = 16384,
+    /**
+     * Provider support to clone files atomically.
+     */
+    FileClone = 32768
+}
+interface IFileSystemProvider {
+    readonly capabilities: FileSystemProviderCapabilities;
+    readonly onDidChangeCapabilities: Event<void>;
+    readonly onDidChangeFile: Event<readonly IFileChange[]>;
+    readonly onDidWatchError?: Event<string>;
+    watch(resource: URI, opts: IWatchOptions): IDisposable;
+    stat(resource: URI): Promise<IStat>;
+    mkdir(resource: URI): Promise<void>;
+    readdir(resource: URI): Promise<[string, FileType][]>;
+    delete(resource: URI, opts: IFileDeleteOptions): Promise<void>;
+    rename(from: URI, to: URI, opts: IFileOverwriteOptions): Promise<void>;
+    copy?(from: URI, to: URI, opts: IFileOverwriteOptions): Promise<void>;
+    readFile?(resource: URI): Promise<Uint8Array>;
+    writeFile?(resource: URI, content: Uint8Array, opts: IFileWriteOptions): Promise<void>;
+    readFileStream?(resource: URI, opts: IFileReadStreamOptions, token: CancellationToken): ReadableStreamEvents<Uint8Array>;
+    open?(resource: URI, opts: IFileOpenOptions): Promise<number>;
+    close?(fd: number): Promise<void>;
+    read?(fd: number, pos: number, data: Uint8Array, offset: number, length: number): Promise<number>;
+    write?(fd: number, pos: number, data: Uint8Array, offset: number, length: number): Promise<number>;
+    cloneFile?(from: URI, to: URI): Promise<void>;
+}
+interface IFileSystemProviderWithFileReadWriteCapability extends IFileSystemProvider {
+    readFile(resource: URI): Promise<Uint8Array>;
+    writeFile(resource: URI, content: Uint8Array, opts: IFileWriteOptions): Promise<void>;
+}
+interface IFileSystemProviderWithFileReadStreamCapability extends IFileSystemProvider {
+    readFileStream(resource: URI, opts: IFileReadStreamOptions, token: CancellationToken): ReadableStreamEvents<Uint8Array>;
+}
+declare enum FileSystemProviderErrorCode {
+    FileExists = "EntryExists",
+    FileNotFound = "EntryNotFound",
+    FileNotADirectory = "EntryNotADirectory",
+    FileIsADirectory = "EntryIsADirectory",
+    FileExceedsStorageQuota = "EntryExceedsStorageQuota",
+    FileTooLarge = "EntryTooLarge",
+    FileWriteLocked = "EntryWriteLocked",
+    NoPermissions = "NoPermissions",
+    Unavailable = "Unavailable",
+    Unknown = "Unknown"
+}
+interface IFileSystemProviderError extends Error {
+    readonly name: string;
+    readonly code: FileSystemProviderErrorCode;
+}
+declare class FileSystemProviderError extends Error implements IFileSystemProviderError {
+    readonly code: FileSystemProviderErrorCode;
+    static create(error: Error | string, code: FileSystemProviderErrorCode): FileSystemProviderError;
+    private constructor();
+}
+interface IFileSystemProviderRegistrationEvent {
+    readonly added: boolean;
+    readonly scheme: string;
+    readonly provider?: IFileSystemProvider;
+}
+interface IFileSystemProviderCapabilitiesChangeEvent {
+    readonly provider: IFileSystemProvider;
+    readonly scheme: string;
+}
+interface IFileSystemProviderActivationEvent {
+    readonly scheme: string;
+    join(promise: Promise<void>): void;
+}
+declare const enum FileOperation {
+    CREATE = 0,
+    DELETE = 1,
+    MOVE = 2,
+    COPY = 3,
+    WRITE = 4
+}
+interface IFileOperationEvent {
+    readonly resource: URI;
+    readonly operation: FileOperation;
+    isOperation(operation: FileOperation.DELETE | FileOperation.WRITE): boolean;
+    isOperation(operation: FileOperation.CREATE | FileOperation.MOVE | FileOperation.COPY): this is IFileOperationEventWithMetadata;
+}
+interface IFileOperationEventWithMetadata extends IFileOperationEvent {
+    readonly target: IFileStatWithMetadata;
+}
+declare class FileOperationEvent implements IFileOperationEvent {
+    readonly resource: URI;
+    readonly operation: FileOperation;
+    readonly target?: IFileStatWithMetadata | undefined;
+    constructor(resource: URI, operation: FileOperation.DELETE | FileOperation.WRITE);
+    constructor(resource: URI, operation: FileOperation.CREATE | FileOperation.MOVE | FileOperation.COPY, target: IFileStatWithMetadata);
+    isOperation(operation: FileOperation.DELETE | FileOperation.WRITE): boolean;
+    isOperation(operation: FileOperation.CREATE | FileOperation.MOVE | FileOperation.COPY): this is IFileOperationEventWithMetadata;
+}
+/**
+ * Possible changes that can occur to a file.
+ */
+declare const enum FileChangeType {
+    UPDATED = 0,
+    ADDED = 1,
+    DELETED = 2
+}
+/**
+ * Identifies a single change in a file.
+ */
+interface IFileChange {
+    /**
+     * The type of change that occurred to the file.
+     */
+    readonly type: FileChangeType;
+    /**
+     * The unified resource identifier of the file that changed.
+     */
+    readonly resource: URI;
+}
+declare class FileChangesEvent {
+    private readonly added;
+    private readonly updated;
+    private readonly deleted;
+    constructor(changes: readonly IFileChange[], ignorePathCasing: boolean);
+    /**
+     * Find out if the file change events match the provided resource.
+     *
+     * Note: when passing `FileChangeType.DELETED`, we consider a match
+     * also when the parent of the resource got deleted.
+     */
+    contains(resource: URI, ...types: FileChangeType[]): boolean;
+    /**
+     * Find out if the file change events either match the provided
+     * resource, or contain a child of this resource.
+     */
+    affects(resource: URI, ...types: FileChangeType[]): boolean;
+    private doContains;
+    /**
+     * Returns if this event contains added files.
+     */
+    gotAdded(): boolean;
+    /**
+     * Returns if this event contains deleted files.
+     */
+    gotDeleted(): boolean;
+    /**
+     * Returns if this event contains updated files.
+     */
+    gotUpdated(): boolean;
+    /**
+     * @deprecated use the `contains` or `affects` method to efficiently find
+     * out if the event relates to a given resource. these methods ensure:
+     * - that there is no expensive lookup needed (by using a `TernarySearchTree`)
+     * - correctly handles `FileChangeType.DELETED` events
+     */
+    readonly rawAdded: URI[];
+    /**
+    * @deprecated use the `contains` or `affects` method to efficiently find
+    * out if the event relates to a given resource. these methods ensure:
+    * - that there is no expensive lookup needed (by using a `TernarySearchTree`)
+    * - correctly handles `FileChangeType.DELETED` events
+    */
+    readonly rawUpdated: URI[];
+    /**
+    * @deprecated use the `contains` or `affects` method to efficiently find
+    * out if the event relates to a given resource. these methods ensure:
+    * - that there is no expensive lookup needed (by using a `TernarySearchTree`)
+    * - correctly handles `FileChangeType.DELETED` events
+    */
+    readonly rawDeleted: URI[];
+}
+interface IBaseFileStat {
+    /**
+     * The unified resource identifier of this file or folder.
+     */
+    readonly resource: URI;
+    /**
+     * The name which is the last segment
+     * of the {{path}}.
+     */
+    readonly name: string;
+    /**
+     * The size of the file.
+     *
+     * The value may or may not be resolved as
+     * it is optional.
+     */
+    readonly size?: number;
+    /**
+     * The last modification date represented as millis from unix epoch.
+     *
+     * The value may or may not be resolved as
+     * it is optional.
+     */
+    readonly mtime?: number;
+    /**
+     * The creation date represented as millis from unix epoch.
+     *
+     * The value may or may not be resolved as
+     * it is optional.
+     */
+    readonly ctime?: number;
+    /**
+     * A unique identifier that represents the
+     * current state of the file or directory.
+     *
+     * The value may or may not be resolved as
+     * it is optional.
+     */
+    readonly etag?: string;
+    /**
+     * The file is read-only.
+     */
+    readonly readonly?: boolean;
+}
+interface IBaseFileStatWithMetadata extends Required<IBaseFileStat> {
+}
+/**
+ * A file resource with meta information and resolved children if any.
+ */
+interface IFileStat extends IBaseFileStat {
+    /**
+     * The resource is a file.
+     */
+    readonly isFile: boolean;
+    /**
+     * The resource is a directory.
+     */
+    readonly isDirectory: boolean;
+    /**
+     * The resource is a symbolic link. Note: even when the
+     * file is a symbolic link, you can test for `FileType.File`
+     * and `FileType.Directory` to know the type of the target
+     * the link points to.
+     */
+    readonly isSymbolicLink: boolean;
+    /**
+     * The children of the file stat or undefined if none.
+     */
+    children: IFileStat[] | undefined;
+}
+interface IFileStatWithMetadata extends IFileStat, IBaseFileStatWithMetadata {
+    readonly mtime: number;
+    readonly ctime: number;
+    readonly etag: string;
+    readonly size: number;
+    readonly readonly: boolean;
+    readonly children: IFileStatWithMetadata[] | undefined;
+}
+interface IFileStatResult {
+    readonly stat?: IFileStat;
+    readonly success: boolean;
+}
+interface IFileStatWithPartialMetadata extends Omit<IFileStatWithMetadata, 'children'> {
+}
+interface IFileContent extends IBaseFileStatWithMetadata {
+    /**
+     * The content of a file as buffer.
+     */
+    readonly value: VSBuffer;
+}
+interface IFileStreamContent extends IBaseFileStatWithMetadata {
+    /**
+     * The content of a file as stream.
+     */
+    readonly value: VSBufferReadableStream;
+}
+interface IBaseReadFileOptions extends IFileReadStreamOptions {
+    /**
+     * The optional etag parameter allows to return early from resolving the resource if
+     * the contents on disk match the etag. This prevents accumulated reading of resources
+     * that have been read already with the same etag.
+     * It is the task of the caller to makes sure to handle this error case from the promise.
+     */
+    readonly etag?: string;
+}
+interface IReadFileStreamOptions extends IBaseReadFileOptions {
+}
+interface IReadFileOptions extends IBaseReadFileOptions {
+    /**
+     * The optional `atomic` flag can be used to make sure
+     * the `readFile` method is not running in parallel with
+     * any `write` operations in the same process.
+     *
+     * Typically you should not need to use this flag but if
+     * for example you are quickly reading a file right after
+     * a file event occurred and the file changes a lot, there
+     * is a chance that a read returns an empty or partial file
+     * because a pending write has not finished yet.
+     *
+     * Note: this does not prevent the file from being written
+     * to from a different process. If you need such atomic
+     * operations, you better use a real database as storage.
+     */
+    readonly atomic?: boolean;
+}
+interface IWriteFileOptions {
+    /**
+     * The last known modification time of the file. This can be used to prevent dirty writes.
+     */
+    readonly mtime?: number;
+    /**
+     * The etag of the file. This can be used to prevent dirty writes.
+     */
+    readonly etag?: string;
+    /**
+     * Whether to attempt to unlock a file before writing.
+     */
+    readonly unlock?: boolean;
+}
+interface IResolveFileOptions {
+    /**
+     * Automatically continue resolving children of a directory until the provided resources
+     * are found.
+     */
+    readonly resolveTo?: readonly URI[];
+    /**
+     * Automatically continue resolving children of a directory if the number of children is 1.
+     */
+    readonly resolveSingleChildDescendants?: boolean;
+    /**
+     * Will resolve mtime, ctime, size and etag of files if enabled. This can have a negative impact
+     * on performance and thus should only be used when these values are required.
+     */
+    readonly resolveMetadata?: boolean;
+}
+interface IResolveMetadataFileOptions extends IResolveFileOptions {
+    readonly resolveMetadata: true;
+}
+interface ICreateFileOptions {
+    /**
+     * Overwrite the file to create if it already exists on disk. Otherwise
+     * an error will be thrown (FILE_MODIFIED_SINCE).
+     */
+    readonly overwrite?: boolean;
+}
+
+export { FileSystemProviderCapabilities as F, IFileService as I, ReadableStreamEvents as R, VSBuffer as V, IFileSystemProviderWithFileReadWriteCapability as a, IFileSystemProviderWithFileReadStreamCapability as b, IStat as c, FileType as d, IFileReadStreamOptions as e, IFileWriteOptions as f, IFileDeleteOptions as g, IFileOverwriteOptions as h, IWatchOptions as i, IFileChange as j, FileSystemProviderError as k, FileSystemProviderErrorCode as l, FileChangeType as m, VSBufferReadable as n, VSBufferReadableStream as o, IFileStatWithMetadata as p, FileOperation as q, ReadableStream as r, IReadFileStreamOptions as s, IWriteFileOptions as t, IBaseFileStatWithMetadata as u, IFileReadLimits as v, IRelativePattern as w };