@codingame/monaco-vscode-api 1.76.8 → 1.78.0-next.0

package/dist/files.d.ts

@@ -0,0 +1,845 @@
+import * as monaco from 'monaco-editor';
+import * as vscode from 'vscode';
+
+/**
+ * An object that performs a cleanup operation when `.dispose()` is called.
+ *
+ * Some examples of how disposables are used:
+ *
+ * - An event listener that removes itself when `.dispose()` is called.
+ * - A resource such as a file system watcher that cleans up the resource when `.dispose()` is called.
+ * - The return value from registering a provider. When `.dispose()` is called, the provider is unregistered.
+ */
+interface IDisposable {
+    dispose(): void;
+}
+/**
+ * Manages a collection of disposable values.
+ *
+ * This is the preferred way to manage multiple disposables. A `DisposableStore` is safer to work with than an
+ * `IDisposable[]` as it considers edge cases, such as registering the same value multiple times or adding an item to a
+ * store that has already been disposed of.
+ */
+declare class DisposableStore implements IDisposable {
+    static DISABLE_DISPOSED_WARNING: boolean;
+    private readonly _toDispose;
+    private _isDisposed;
+    constructor();
+    /**
+     * Dispose of all registered disposables and mark this object as disposed.
+     *
+     * Any future disposables added to this object will be disposed of on `add`.
+     */
+    dispose(): void;
+    /**
+     * @return `true` if this object has been disposed of.
+     */
+    get isDisposed(): boolean;
+    /**
+     * Dispose of all registered disposables but do not mark this object as disposed.
+     */
+    clear(): void;
+    /**
+     * Add a new {@link IDisposable disposable} to the collection.
+     */
+    add<T extends IDisposable>(o: T): T;
+}
+
+interface CancellationToken {
+    /**
+     * A flag signalling is cancellation has been requested.
+     */
+    readonly isCancellationRequested: boolean;
+    /**
+     * An event which fires when cancellation is requested. This event
+     * only ever fires `once` as cancellation can only happen once. Listeners
+     * that are registered after cancellation will be called (next event loop run),
+     * but also only once.
+     *
+     * @event
+     */
+    readonly onCancellationRequested: (listener: (e: any) => any, thisArgs?: any, disposables?: IDisposable[]) => IDisposable;
+}
+declare namespace CancellationToken {
+    function isCancellationToken(thing: unknown): thing is CancellationToken;
+    const None: Readonly<CancellationToken>;
+    const Cancelled: Readonly<CancellationToken>;
+}
+
+interface IObservable<T, TChange = void> {
+    readonly TChange: TChange;
+    /**
+     * Reads the current value.
+     *
+     * Must not be called from {@link IObserver.handleChange}.
+     */
+    get(): T;
+    /**
+     * Adds an observer.
+     */
+    addObserver(observer: IObserver): void;
+    removeObserver(observer: IObserver): void;
+    /**
+     * Subscribes the reader to this observable and returns the current value of this observable.
+     */
+    read(reader: IReader): T;
+    map<TNew>(fn: (value: T) => TNew): IObservable<TNew>;
+    readonly debugName: string;
+}
+interface IReader {
+    /**
+     * Reports an observable that was read.
+     *
+     * Is called by {@link IObservable.read}.
+     */
+    subscribeTo<T>(observable: IObservable<T, any>): void;
+}
+interface IObserver {
+    /**
+     * Indicates that an update operation is about to begin.
+     *
+     * During an update, invariants might not hold for subscribed observables and
+     * change events might be delayed.
+     * However, all changes must be reported before all update operations are over.
+     */
+    beginUpdate<T>(observable: IObservable<T>): void;
+    /**
+     * Is called by a subscribed observable immediately after it notices a change.
+     *
+     * When {@link IObservable.get} returns and no change has been reported,
+     * there has been no change for that observable.
+     *
+     * Implementations must not call into other observables!
+     * The change should be processed when {@link IObserver.endUpdate} is called.
+     */
+    handleChange<T, TChange>(observable: IObservable<T, TChange>, change: TChange): void;
+    /**
+     * Indicates that an update operation has completed.
+     */
+    endUpdate<T>(observable: IObservable<T>): void;
+}
+
+/**
+ * Can be passed into the Delayed to defer using a microtask
+ * */
+declare const MicrotaskDelay: unique symbol;
+
+/**
+ * An event with zero or one parameters that can be subscribed to. The event is a function itself.
+ */
+type Event<T> = vscode.Event<T>
+declare namespace Event {
+    const None: Event<any>;
+    /**
+     * Given an event, returns another event which debounces calls and defers the listeners to a later task via a shared
+     * `setTimeout`. The event is converted into a signal (`Event<void>`) to avoid additional object creation as a
+     * result of merging events and to try prevent race conditions that could arise when using related deferred and
+     * non-deferred events.
+     *
+     * This is useful for deferring non-critical work (eg. general UI updates) to ensure it does not block critical work
+     * (eg. latency of keypress to text rendered).
+     *
+     * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
+     * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
+     * returned event causes this utility to leak a listener on the original event.
+     *
+     * @param event The event source for the new event.
+     * @param disposable A disposable store to add the new EventEmitter to.
+     */
+    function defer(event: Event<unknown>, disposable?: DisposableStore): Event<void>;
+    /**
+     * Given an event, returns another event which only fires once.
+     *
+     * @param event The event source for the new event.
+     */
+    function once<T>(event: Event<T>): Event<T>;
+    /**
+     * Maps an event of one type into an event of another type using a mapping function, similar to how
+     * `Array.prototype.map` works.
+     *
+     * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
+     * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
+     * returned event causes this utility to leak a listener on the original event.
+     *
+     * @param event The event source for the new event.
+     * @param map The mapping function.
+     * @param disposable A disposable store to add the new EventEmitter to.
+     */
+    function map<I, O>(event: Event<I>, map: (i: I) => O, disposable?: DisposableStore): Event<O>;
+    /**
+     * Wraps an event in another event that performs some function on the event object before firing.
+     *
+     * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
+     * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
+     * returned event causes this utility to leak a listener on the original event.
+     *
+     * @param event The event source for the new event.
+     * @param each The function to perform on the event object.
+     * @param disposable A disposable store to add the new EventEmitter to.
+     */
+    function forEach<I>(event: Event<I>, each: (i: I) => void, disposable?: DisposableStore): Event<I>;
+    /**
+     * Wraps an event in another event that fires only when some condition is met.
+     *
+     * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
+     * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
+     * returned event causes this utility to leak a listener on the original event.
+     *
+     * @param event The event source for the new event.
+     * @param filter The filter function that defines the condition. The event will fire for the object if this function
+     * returns true.
+     * @param disposable A disposable store to add the new EventEmitter to.
+     */
+    function filter<T, U>(event: Event<T | U>, filter: (e: T | U) => e is T, disposable?: DisposableStore): Event<T>;
+    function filter<T>(event: Event<T>, filter: (e: T) => boolean, disposable?: DisposableStore): Event<T>;
+    function filter<T, R>(event: Event<T | R>, filter: (e: T | R) => e is R, disposable?: DisposableStore): Event<R>;
+    /**
+     * Given an event, returns the same event but typed as `Event<void>`.
+     */
+    function signal<T>(event: Event<T>): Event<void>;
+    /**
+     * Given a collection of events, returns a single event which emits whenever any of the provided events emit.
+     */
+    function any<T>(...events: Event<T>[]): Event<T>;
+    function any(...events: Event<any>[]): Event<void>;
+    /**
+     * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
+     * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
+     * returned event causes this utility to leak a listener on the original event.
+     */
+    function reduce<I, O>(event: Event<I>, merge: (last: O | undefined, event: I) => O, initial?: O, disposable?: DisposableStore): Event<O>;
+    /**
+     * Given an event, creates a new emitter that event that will debounce events based on {@link delay} and give an
+     * array event object of all events that fired.
+     *
+     * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
+     * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
+     * returned event causes this utility to leak a listener on the original event.
+     *
+     * @param event The original event to debounce.
+     * @param merge A function that reduces all events into a single event.
+     * @param delay The number of milliseconds to debounce.
+     * @param leading Whether to fire a leading event without debouncing.
+     * @param flushOnListenerRemove Whether to fire all debounced events when a listener is removed. If this is not
+     * specified, some events could go missing. Use this if it's important that all events are processed, even if the
+     * listener gets disposed before the debounced event fires.
+     * @param leakWarningThreshold See {@link EmitterOptions.leakWarningThreshold}.
+     * @param disposable A disposable store to register the debounce emitter to.
+     */
+    function debounce<T>(event: Event<T>, merge: (last: T | undefined, event: T) => T, delay?: number | typeof MicrotaskDelay, leading?: boolean, flushOnListenerRemove?: boolean, leakWarningThreshold?: number, disposable?: DisposableStore): Event<T>;
+    function debounce<I, O>(event: Event<I>, merge: (last: O | undefined, event: I) => O, delay?: number | typeof MicrotaskDelay, leading?: boolean, flushOnListenerRemove?: boolean, leakWarningThreshold?: number, disposable?: DisposableStore): Event<O>;
+    /**
+     * Debounces an event, firing after some delay (default=0) with an array of all event original objects.
+     *
+     * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
+     * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
+     * returned event causes this utility to leak a listener on the original event.
+     */
+    function accumulate<T>(event: Event<T>, delay?: number, disposable?: DisposableStore): Event<T[]>;
+    /**
+     * Filters an event such that some condition is _not_ met more than once in a row, effectively ensuring duplicate
+     * event objects from different sources do not fire the same event object.
+     *
+     * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
+     * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
+     * returned event causes this utility to leak a listener on the original event.
+     *
+     * @param event The event source for the new event.
+     * @param equals The equality condition.
+     * @param disposable A disposable store to add the new EventEmitter to.
+     *
+     * @example
+     * ```
+     * // Fire only one time when a single window is opened or focused
+     * Event.latch(Event.any(onDidOpenWindow, onDidFocusWindow))
+     * ```
+     */
+    function latch<T>(event: Event<T>, equals?: (a: T, b: T) => boolean, disposable?: DisposableStore): Event<T>;
+    /**
+     * Splits an event whose parameter is a union type into 2 separate events for each type in the union.
+     *
+     * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
+     * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
+     * returned event causes this utility to leak a listener on the original event.
+     *
+     * @example
+     * ```
+     * const event = new EventEmitter<number | undefined>().event;
+     * const [numberEvent, undefinedEvent] = Event.split(event, isUndefined);
+     * ```
+     *
+     * @param event The event source for the new event.
+     * @param isT A function that determines what event is of the first type.
+     * @param disposable A disposable store to add the new EventEmitter to.
+     */
+    function split<T, U>(event: Event<T | U>, isT: (e: T | U) => e is T, disposable?: DisposableStore): [Event<T>, Event<U>];
+    /**
+     * Buffers an event until it has a listener attached.
+     *
+     * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
+     * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
+     * returned event causes this utility to leak a listener on the original event.
+     *
+     * @param event The event source for the new event.
+     * @param flushAfterTimeout Determines whether to flush the buffer after a timeout immediately or after a
+     * `setTimeout` when the first event listener is added.
+     * @param _buffer Internal: A source event array used for tests.
+     *
+     * @example
+     * ```
+     * // Start accumulating events, when the first listener is attached, flush
+     * // the event after a timeout such that multiple listeners attached before
+     * // the timeout would receive the event
+     * this.onInstallExtension = Event.buffer(service.onInstallExtension, true);
+     * ```
+     */
+    function buffer<T>(event: Event<T>, flushAfterTimeout?: boolean, _buffer?: T[]): Event<T>;
+    interface IChainableEvent<T> extends IDisposable {
+        event: Event<T>;
+        map<O>(fn: (i: T) => O): IChainableEvent<O>;
+        forEach(fn: (i: T) => void): IChainableEvent<T>;
+        filter(fn: (e: T) => boolean): IChainableEvent<T>;
+        filter<R>(fn: (e: T | R) => e is R): IChainableEvent<R>;
+        reduce<R>(merge: (last: R | undefined, event: T) => R, initial?: R): IChainableEvent<R>;
+        latch(): IChainableEvent<T>;
+        debounce(merge: (last: T | undefined, event: T) => T, delay?: number, leading?: boolean, flushOnListenerRemove?: boolean, leakWarningThreshold?: number): IChainableEvent<T>;
+        debounce<R>(merge: (last: R | undefined, event: T) => R, delay?: number, leading?: boolean, flushOnListenerRemove?: boolean, leakWarningThreshold?: number): IChainableEvent<R>;
+        on(listener: (e: T) => any, thisArgs?: any, disposables?: IDisposable[] | DisposableStore): IDisposable;
+        once(listener: (e: T) => any, thisArgs?: any, disposables?: IDisposable[]): IDisposable;
+    }
+    /**
+     * Wraps the event in an {@link IChainableEvent}, allowing a more functional programming style.
+     *
+     * @example
+     * ```
+     * // Normal
+     * const onEnterPressNormal = Event.filter(
+     *   Event.map(onKeyPress.event, e => new StandardKeyboardEvent(e)),
+     *   e.keyCode === KeyCode.Enter
+     * ).event;
+     *
+     * // Using chain
+     * const onEnterPressChain = Event.chain(onKeyPress.event)
+     *   .map(e => new StandardKeyboardEvent(e))
+     *   .filter(e => e.keyCode === KeyCode.Enter)
+     *   .event;
+     * ```
+     */
+    function chain<T>(event: Event<T>): IChainableEvent<T>;
+    interface NodeEventEmitter {
+        on(event: string | symbol, listener: Function): unknown;
+        removeListener(event: string | symbol, listener: Function): unknown;
+    }
+    /**
+     * Creates an {@link Event} from a node event emitter.
+     */
+    function fromNodeEventEmitter<T>(emitter: NodeEventEmitter, eventName: string, map?: (...args: any[]) => T): Event<T>;
+    interface DOMEventEmitter {
+        addEventListener(event: string | symbol, listener: Function): void;
+        removeEventListener(event: string | symbol, listener: Function): void;
+    }
+    /**
+     * Creates an {@link Event} from a DOM event emitter.
+     */
+    function fromDOMEventEmitter<T>(emitter: DOMEventEmitter, eventName: string, map?: (...args: any[]) => T): Event<T>;
+    /**
+     * Creates a promise out of an event, using the {@link Event.once} helper.
+     */
+    function toPromise<T>(event: Event<T>): Promise<T>;
+    /**
+     * Adds a listener to an event and calls the listener immediately with undefined as the event object.
+     *
+     * @example
+     * ```
+     * // Initialize the UI and update it when dataChangeEvent fires
+     * runAndSubscribe(dataChangeEvent, () => this._updateUI());
+     * ```
+     */
+    function runAndSubscribe<T>(event: Event<T>, handler: (e: T | undefined) => any): IDisposable;
+    /**
+     * Adds a listener to an event and calls the listener immediately with undefined as the event object. A new
+     * {@link DisposableStore} is passed to the listener which is disposed when the returned disposable is disposed.
+     */
+    function runAndSubscribeWithStore<T>(event: Event<T>, handler: (e: T | undefined, disposableStore: DisposableStore) => any): IDisposable;
+    function fromObservable<T>(obs: IObservable<T, any>, store?: DisposableStore): Event<T>;
+}
+
+/**
+ * Uniform Resource Identifier (URI) http://tools.ietf.org/html/rfc3986.
+ * This class is a simple parser which creates the basic component parts
+ * (http://tools.ietf.org/html/rfc3986#section-3) with minimal validation
+ * and encoding.
+ *
+ * ```txt
+ *       foo://example.com:8042/over/there?name=ferret#nose
+ *       \_/   \______________/\_________/ \_________/ \__/
+ *        |           |            |            |        |
+ *     scheme     authority       path        query   fragment
+ *        |   _____________________|__
+ *       / \ /                        \
+ *       urn:example:animal:ferret:nose
+ * ```
+ */
+declare class URI implements UriComponents {
+    static isUri(thing: any): thing is URI;
+    /**
+     * scheme is the 'http' part of 'http://www.example.com/some/path?query#fragment'.
+     * The part before the first colon.
+     */
+    readonly scheme: string;
+    /**
+     * authority is the 'www.example.com' part of 'http://www.example.com/some/path?query#fragment'.
+     * The part between the first double slashes and the next slash.
+     */
+    readonly authority: string;
+    /**
+     * path is the '/some/path' part of 'http://www.example.com/some/path?query#fragment'.
+     */
+    readonly path: string;
+    /**
+     * query is the 'query' part of 'http://www.example.com/some/path?query#fragment'.
+     */
+    readonly query: string;
+    /**
+     * fragment is the 'fragment' part of 'http://www.example.com/some/path?query#fragment'.
+     */
+    readonly fragment: string;
+    /**
+     * @internal
+     */
+    protected constructor(scheme: string, authority?: string, path?: string, query?: string, fragment?: string, _strict?: boolean);
+    /**
+     * @internal
+     */
+    protected constructor(components: UriComponents);
+    /**
+     * Returns a string representing the corresponding file system path of this URI.
+     * Will handle UNC paths, normalizes windows drive letters to lower-case, and uses the
+     * platform specific path separator.
+     *
+     * * Will *not* validate the path for invalid characters and semantics.
+     * * Will *not* look at the scheme of this URI.
+     * * The result shall *not* be used for display purposes but for accessing a file on disk.
+     *
+     *
+     * The *difference* to `URI#path` is the use of the platform specific separator and the handling
+     * of UNC paths. See the below sample of a file-uri with an authority (UNC path).
+     *
+     * ```ts
+        const u = URI.parse('file://server/c$/folder/file.txt')
+        u.authority === 'server'
+        u.path === '/shares/c$/file.txt'
+        u.fsPath === '\\server\c$\folder\file.txt'
+    ```
+     *
+     * Using `URI#path` to read a file (using fs-apis) would not be enough because parts of the path,
+     * namely the server name, would be missing. Therefore `URI#fsPath` exists - it's sugar to ease working
+     * with URIs that represent files on disk (`file` scheme).
+     */
+    get fsPath(): string;
+    with(change: {
+        scheme?: string;
+        authority?: string | null;
+        path?: string | null;
+        query?: string | null;
+        fragment?: string | null;
+    }): URI;
+    /**
+     * Creates a new URI from a string, e.g. `http://www.example.com/some/path`,
+     * `file:///usr/home`, or `scheme:with/path`.
+     *
+     * @param value A string which represents an URI (see `URI#toString`).
+     */
+    static parse(value: string, _strict?: boolean): URI;
+    /**
+     * Creates a new URI from a file system path, e.g. `c:\my\files`,
+     * `/usr/home`, or `\\server\share\some\path`.
+     *
+     * The *difference* between `URI#parse` and `URI#file` is that the latter treats the argument
+     * as path, not as stringified-uri. E.g. `URI.file(path)` is **not the same as**
+     * `URI.parse('file://' + path)` because the path might contain characters that are
+     * interpreted (# and ?). See the following sample:
+     * ```ts
+    const good = URI.file('/coding/c#/project1');
+    good.scheme === 'file';
+    good.path === '/coding/c#/project1';
+    good.fragment === '';
+    const bad = URI.parse('file://' + '/coding/c#/project1');
+    bad.scheme === 'file';
+    bad.path === '/coding/c'; // path is now broken
+    bad.fragment === '/project1';
+    ```
+     *
+     * @param path A file system path (see `URI#fsPath`)
+     */
+    static file(path: string): URI;
+    static from(components: {
+        scheme: string;
+        authority?: string;
+        path?: string;
+        query?: string;
+        fragment?: string;
+    }): URI;
+    /**
+     * Join a URI path with path fragments and normalizes the resulting path.
+     *
+     * @param uri The input URI.
+     * @param pathFragment The path fragment to add to the URI path.
+     * @returns The resulting URI.
+     */
+    static joinPath(uri: URI, ...pathFragment: string[]): URI;
+    /**
+     * Creates a string representation for this URI. It's guaranteed that calling
+     * `URI.parse` with the result of this function creates an URI which is equal
+     * to this URI.
+     *
+     * * The result shall *not* be used for display purposes but for externalization or transport.
+     * * The result will be encoded using the percentage encoding and encoding happens mostly
+     * ignore the scheme-specific encoding rules.
+     *
+     * @param skipEncoding Do not encode the result, default is `false`
+     */
+    toString(skipEncoding?: boolean): string;
+    toJSON(): UriComponents;
+    static revive(data: UriComponents | URI): URI;
+    static revive(data: UriComponents | URI | undefined): URI | undefined;
+    static revive(data: UriComponents | URI | null): URI | null;
+    static revive(data: UriComponents | URI | undefined | null): URI | undefined | null;
+}
+interface UriComponents {
+    scheme: string;
+    authority: string;
+    path: string;
+    query: string;
+    fragment: string;
+}
+
+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;
+}
+
+type IEditorOverrideServices = monaco.editor.IEditorOverrideServices
+
+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;
+}
+
+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;
+    /**
+     * If the file exceeds the given size, an error of kind
+     * `FILE_EXCEEDS_MEMORY_LIMIT` will be thrown.
+     */
+    memory?: 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>;
+}
+declare enum FileSystemProviderErrorCode {
+    FileExists = "EntryExists",
+    FileNotFound = "EntryNotFound",
+    FileNotADirectory = "EntryNotADirectory",
+    FileIsADirectory = "EntryIsADirectory",
+    FileExceedsMemoryLimit = "EntryExceedsMemoryLimit",
+    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();
+}
+/**
+ * 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 abstract class SimpleTextFileSystemProvider implements IFileSystemProviderWithFileReadWriteCapability {
+    onDidChangeCapabilities: Event<any>;
+    capabilities: number;
+    protected abstract getFileContent(resource: URI): Promise<string | undefined>;
+    protected abstract setFileContent(resource: URI, content: string, opts: IFileWriteOptions): Promise<void>;
+    onDidChangeFile: Event<readonly IFileChange[]>;
+    readFile(resource: URI): Promise<Uint8Array>;
+    writeFile(resource: URI, content: Uint8Array, opts: IFileWriteOptions): Promise<void>;
+    watch(): IDisposable;
+    stat(resource: URI): Promise<IStat>;
+    mkdir(): Promise<void>;
+    readdir(): Promise<[string, FileType][]>;
+    delete(): Promise<void>;
+    rename(): Promise<void>;
+    onDidWatchError: Event<any>;
+}
+declare function getServiceOverride(): IEditorOverrideServices;
+declare function registerExtensionFile(extensionLocation: URI, path: string, getContent: () => Promise<string>): IDisposable;
+declare function registerFileSystemOverlay(provider: IFileSystemProviderWithFileReadWriteCapability): IDisposable;
+
+export { FileChangeType, FileSystemProviderCapabilities, FileSystemProviderError, FileSystemProviderErrorCode, IFileChange, IFileDeleteOptions, IFileOverwriteOptions, IFileSystemProviderWithFileReadWriteCapability, IFileWriteOptions, IStat, IWatchOptions, SimpleTextFileSystemProvider, getServiceOverride as default, registerExtensionFile, registerFileSystemOverlay };