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

package/dist/modelEditor.d.ts

@@ -48,6 +48,27 @@ interface IReference<T> extends IDisposable {
     readonly object: 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;
     /**
@@ -149,15 +170,28 @@ declare namespace Event {
      */
     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>;
@@ -167,8 +201,7 @@ declare namespace Event {
      */
     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.
+     * 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>;
@@ -207,9 +240,22 @@ declare namespace 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>;
     /**
@@ -231,9 +277,24 @@ declare namespace Event {
      */
     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 {
@@ -249,234 +310,1515 @@ declare namespace Event {
         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>;
 }
 
 /**
- * Text snapshot that works like an iterator.
- * Will try to return chunks of roughly ~64KB size.
- * Will return null when finished.
- */
-interface ITextSnapshot {
-    read(): string | null;
-}
-/**
- * A model.
- */
-type ITextModel = monaco.editor.ITextModel
-
-/**
- * A rich code editor.
+ * 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
+ * ```
  */
-type ICodeEditor = monaco.editor.ICodeEditor
-
-interface IEditorModel {
+declare class URI implements UriComponents {
+    static isUri(thing: any): thing is URI;
     /**
-     * Emitted when the model is about to be disposed.
+     * scheme is the 'http' part of 'http://www.example.com/some/path?query#fragment'.
+     * The part before the first colon.
      */
-    readonly onWillDispose: Event<void>;
+    readonly scheme: string;
     /**
-     * Resolves the model.
+     * 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.
      */
-    resolve(): Promise<void>;
+    readonly authority: string;
     /**
-     * Find out if the editor model was resolved or not.
+     * path is the '/some/path' part of 'http://www.example.com/some/path?query#fragment'.
      */
-    isResolved(): boolean;
+    readonly path: string;
     /**
-     * Find out if this model has been disposed.
+     * query is the 'query' part of 'http://www.example.com/some/path?query#fragment'.
      */
-    isDisposed(): boolean;
+    readonly query: string;
     /**
-     * Dispose associated resources
+     * fragment is the 'fragment' part of 'http://www.example.com/some/path?query#fragment'.
      */
-    dispose(): void;
-}
-declare enum EditorActivation {
+    readonly fragment: string;
     /**
-     * Activate the editor after it opened. This will automatically restore
-     * the editor if it is minimized.
+     * @internal
      */
-    ACTIVATE = 1,
+    protected constructor(scheme: string, authority?: string, path?: string, query?: string, fragment?: string, _strict?: boolean);
     /**
-     * Only restore the editor if it is minimized but do not activate it.
+     * @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.
      *
-     * Note: will only work in combination with the `preserveFocus: true` option.
-     * Otherwise, if focus moves into the editor, it will activate and restore
-     * automatically.
+     * * 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).
      */
-    RESTORE = 2,
+    get fsPath(): string;
+    with(change: {
+        scheme?: string;
+        authority?: string | null;
+        path?: string | null;
+        query?: string | null;
+        fragment?: string | null;
+    }): URI;
     /**
-     * Preserve the current active editor.
+     * Creates a new URI from a string, e.g. `http://www.example.com/some/path`,
+     * `file:///usr/home`, or `scheme:with/path`.
      *
-     * Note: will only work in combination with the `preserveFocus: true` option.
-     * Otherwise, if focus moves into the editor, it will activate and restore
-     * automatically.
+     * @param value A string which represents an URI (see `URI#toString`).
      */
-    PRESERVE = 3
-}
-declare enum EditorResolution {
+    static parse(value: string, _strict?: boolean): URI;
     /**
-     * Displays a picker and allows the user to decide which editor to use.
+     * 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`)
      */
-    PICK = 0,
+    static file(path: string): URI;
+    static from(components: {
+        scheme: string;
+        authority?: string;
+        path?: string;
+        query?: string;
+        fragment?: string;
+    }): URI;
     /**
-     * Only exclusive editors are considered.
+     * 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.
      */
-    EXCLUSIVE_ONLY = 1
+    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;
 }
-declare enum EditorOpenSource {
+interface UriComponents {
+    scheme: string;
+    authority: string;
+    path: string;
+    query: string;
+    fragment: string;
+}
+
+/**
+ * A position in the editor. This interface is suitable for serialization.
+ */
+interface IPosition {
     /**
-     * Default: the editor is opening via a programmatic call
-     * to the editor service API.
+     * line number (starts at 1)
      */
-    API = 0,
+    readonly lineNumber: number;
     /**
-     * Indicates that a user action triggered the opening, e.g.
-     * via mouse or keyboard use.
+     * column (the first character in a line is between column 1 and column 2)
      */
-    USER = 1
+    readonly column: number;
 }
-interface IEditorOptions {
+/**
+ * A position in the editor.
+ */
+declare class Position {
     /**
-     * Tells the editor to not receive keyboard focus when the editor is being opened.
-     *
-     * Will also not activate the group the editor opens in unless the group is already
-     * the active one. This behaviour can be overridden via the `activation` option.
+     * line number (starts at 1)
      */
-    preserveFocus?: boolean;
+    readonly lineNumber: number;
     /**
-     * This option is only relevant if an editor is opened into a group that is not active
-     * already and allows to control if the inactive group should become active, restored
-     * or preserved.
-     *
-     * By default, the editor group will become active unless `preserveFocus` or `inactive`
-     * is specified.
+     * column (the first character in a line is between column 1 and column 2)
      */
-    activation?: EditorActivation;
+    readonly column: number;
+    constructor(lineNumber: number, column: number);
     /**
-     * Tells the editor to reload the editor input in the editor even if it is identical to the one
-     * already showing. By default, the editor will not reload the input if it is identical to the
-     * one showing.
+     * Create a new position from this position.
+     *
+     * @param newLineNumber new line number
+     * @param newColumn new column
      */
-    forceReload?: boolean;
+    with(newLineNumber?: number, newColumn?: number): Position;
     /**
-     * Will reveal the editor if it is already opened and visible in any of the opened editor groups.
+     * Derive a new position from this position.
      *
-     * Note that this option is just a hint that might be ignored if the user wants to open an editor explicitly
-     * to the side of another one or into a specific editor group.
+     * @param deltaLineNumber line number delta
+     * @param deltaColumn column delta
      */
-    revealIfVisible?: boolean;
+    delta(deltaLineNumber?: number, deltaColumn?: number): Position;
     /**
-     * Will reveal the editor if it is already opened (even when not visible) in any of the opened editor groups.
-     *
-     * Note that this option is just a hint that might be ignored if the user wants to open an editor explicitly
-     * to the side of another one or into a specific editor group.
+     * Test if this position equals other position
      */
-    revealIfOpened?: boolean;
+    equals(other: IPosition): boolean;
     /**
-     * An editor that is pinned remains in the editor stack even when another editor is being opened.
-     * An editor that is not pinned will always get replaced by another editor that is not pinned.
+     * Test if position `a` equals position `b`
      */
-    pinned?: boolean;
+    static equals(a: IPosition | null, b: IPosition | null): boolean;
     /**
-     * An editor that is sticky moves to the beginning of the editors list within the group and will remain
-     * there unless explicitly closed. Operations such as "Close All" will not close sticky editors.
+     * Test if this position is before other position.
+     * If the two positions are equal, the result will be false.
      */
-    sticky?: boolean;
+    isBefore(other: IPosition): boolean;
     /**
-     * The index in the document stack where to insert the editor into when opening.
+     * Test if position `a` is before position `b`.
+     * If the two positions are equal, the result will be false.
      */
-    index?: number;
+    static isBefore(a: IPosition, b: IPosition): boolean;
     /**
-     * An active editor that is opened will show its contents directly. Set to true to open an editor
-     * in the background without loading its contents.
-     *
-     * Will also not activate the group the editor opens in unless the group is already
-     * the active one. This behaviour can be overridden via the `activation` option.
+     * Test if this position is before other position.
+     * If the two positions are equal, the result will be true.
      */
-    inactive?: boolean;
+    isBeforeOrEqual(other: IPosition): boolean;
     /**
-     * Will not show an error in case opening the editor fails and thus allows to show a custom error
-     * message as needed. By default, an error will be presented as notification if opening was not possible.
+     * Test if position `a` is before position `b`.
+     * If the two positions are equal, the result will be true.
      */
+    static isBeforeOrEqual(a: IPosition, b: IPosition): boolean;
     /**
-     * In case of an error opening the editor, will not present this error to the user (e.g. by showing
-     * a generic placeholder in the editor area). So it is up to the caller to provide error information
-     * in that case.
-     *
-     * By default, an error when opening an editor will result in a placeholder editor that shows the error.
-     * In certain cases a modal dialog may be presented to ask the user for further action.
+     * A function that compares positions, useful for sorting
      */
-    ignoreError?: boolean;
+    static compare(a: IPosition, b: IPosition): number;
     /**
-     * Allows to override the editor that should be used to display the input:
-     * - `undefined`: let the editor decide for itself
-     * - `string`: specific override by id
-     * - `EditorResolution`: specific override handling
+     * Clone this position.
      */
-    override?: string | EditorResolution;
+    clone(): Position;
     /**
-     * A optional hint to signal in which context the editor opens.
-     *
-     * If configured to be `EditorOpenSource.USER`, this hint can be
-     * used in various places to control the experience. For example,
-     * if the editor to open fails with an error, a notification could
-     * inform about this in a modal dialog. If the editor opened through
-     * some background task, the notification would show in the background,
-     * not as a modal dialog.
+     * Convert to a human-readable representation.
      */
-    source?: EditorOpenSource;
+    toString(): string;
     /**
-     * An optional property to signal that certain view state should be
-     * applied when opening the editor.
+     * Create a `Position` from an `IPosition`.
      */
-    viewState?: object;
+    static lift(pos: IPosition): Position;
+    /**
+     * Test if `obj` is an `IPosition`.
+     */
+    static isIPosition(obj: any): obj is IPosition;
 }
 
-type IEditorOverrideServices = monaco.editor.IEditorOverrideServices
-
-interface ITextEditorModel extends IEditorModel {
+/**
+ * A range in the editor. This interface is suitable for serialization.
+ */
+interface IRange {
     /**
-     * Provides access to the underlying `ITextModel`.
+     * Line number on which the range starts (starts at 1).
      */
-    readonly textEditorModel: ITextModel | null;
+    readonly startLineNumber: number;
     /**
-     * Creates a snapshot of the model's contents.
+     * Column on which the range starts in line `startLineNumber` (starts at 1).
      */
-    createSnapshot(this: IResolvedTextEditorModel): ITextSnapshot;
-    createSnapshot(this: ITextEditorModel): ITextSnapshot | null;
+    readonly startColumn: number;
     /**
-     * Signals if this model is readonly or not.
+     * Line number on which the range ends.
      */
-    isReadonly(): boolean;
+    readonly endLineNumber: number;
     /**
-     * The language id of the text model if known.
+     * Column on which the range ends in line `endLineNumber`.
      */
-    getLanguageId(): string | undefined;
+    readonly endColumn: number;
 }
-interface IResolvedTextEditorModel extends ITextEditorModel {
+/**
+ * A range in the editor. (startLineNumber,startColumn) is <= (endLineNumber,endColumn)
+ */
+declare class Range {
     /**
-     * Same as ITextEditorModel#textEditorModel, but never null.
+     * Line number on which the range starts (starts at 1).
+     */
+    readonly startLineNumber: number;
+    /**
+     * Column on which the range starts in line `startLineNumber` (starts at 1).
+     */
+    readonly startColumn: number;
+    /**
+     * Line number on which the range ends.
+     */
+    readonly endLineNumber: number;
+    /**
+     * Column on which the range ends in line `endLineNumber`.
+     */
+    readonly endColumn: number;
+    constructor(startLineNumber: number, startColumn: number, endLineNumber: number, endColumn: number);
+    /**
+     * Test if this range is empty.
+     */
+    isEmpty(): boolean;
+    /**
+     * Test if `range` is empty.
+     */
+    static isEmpty(range: IRange): boolean;
+    /**
+     * Test if position is in this range. If the position is at the edges, will return true.
+     */
+    containsPosition(position: IPosition): boolean;
+    /**
+     * Test if `position` is in `range`. If the position is at the edges, will return true.
+     */
+    static containsPosition(range: IRange, position: IPosition): boolean;
+    /**
+     * Test if `position` is in `range`. If the position is at the edges, will return false.
+     * @internal
+     */
+    static strictContainsPosition(range: IRange, position: IPosition): boolean;
+    /**
+     * Test if range is in this range. If the range is equal to this range, will return true.
+     */
+    containsRange(range: IRange): boolean;
+    /**
+     * Test if `otherRange` is in `range`. If the ranges are equal, will return true.
+     */
+    static containsRange(range: IRange, otherRange: IRange): boolean;
+    /**
+     * Test if `range` is strictly in this range. `range` must start after and end before this range for the result to be true.
+     */
+    strictContainsRange(range: IRange): boolean;
+    /**
+     * Test if `otherRange` is strictly in `range` (must start after, and end before). If the ranges are equal, will return false.
+     */
+    static strictContainsRange(range: IRange, otherRange: IRange): boolean;
+    /**
+     * A reunion of the two ranges.
+     * The smallest position will be used as the start point, and the largest one as the end point.
+     */
+    plusRange(range: IRange): Range;
+    /**
+     * A reunion of the two ranges.
+     * The smallest position will be used as the start point, and the largest one as the end point.
+     */
+    static plusRange(a: IRange, b: IRange): Range;
+    /**
+     * A intersection of the two ranges.
+     */
+    intersectRanges(range: IRange): Range | null;
+    /**
+     * A intersection of the two ranges.
+     */
+    static intersectRanges(a: IRange, b: IRange): Range | null;
+    /**
+     * Test if this range equals other.
+     */
+    equalsRange(other: IRange | null | undefined): boolean;
+    /**
+     * Test if range `a` equals `b`.
+     */
+    static equalsRange(a: IRange | null | undefined, b: IRange | null | undefined): boolean;
+    /**
+     * Return the end position (which will be after or equal to the start position)
+     */
+    getEndPosition(): Position;
+    /**
+     * Return the end position (which will be after or equal to the start position)
+     */
+    static getEndPosition(range: IRange): Position;
+    /**
+     * Return the start position (which will be before or equal to the end position)
      */
+    getStartPosition(): Position;
+    /**
+     * Return the start position (which will be before or equal to the end position)
+     */
+    static getStartPosition(range: IRange): Position;
+    /**
+     * Transform to a user presentable string representation.
+     */
+    toString(): string;
+    /**
+     * Create a new range using this range's start position, and using endLineNumber and endColumn as the end position.
+     */
+    setEndPosition(endLineNumber: number, endColumn: number): Range;
+    /**
+     * Create a new range using this range's end position, and using startLineNumber and startColumn as the start position.
+     */
+    setStartPosition(startLineNumber: number, startColumn: number): Range;
+    /**
+     * Create a new empty range using this range's start position.
+     */
+    collapseToStart(): Range;
+    /**
+     * Create a new empty range using this range's start position.
+     */
+    static collapseToStart(range: IRange): Range;
+    /**
+     * Create a new empty range using this range's end position.
+     */
+    collapseToEnd(): Range;
+    /**
+     * Create a new empty range using this range's end position.
+     */
+    static collapseToEnd(range: IRange): Range;
+    /**
+     * Moves the range by the given amount of lines.
+     */
+    delta(lineCount: number): Range;
+    static fromPositions(start: IPosition, end?: IPosition): Range;
+    /**
+     * Create a `Range` from an `IRange`.
+     */
+    static lift(range: undefined | null): null;
+    static lift(range: IRange): Range;
+    static lift(range: IRange | undefined | null): Range | null;
+    /**
+     * Test if `obj` is an `IRange`.
+     */
+    static isIRange(obj: any): obj is IRange;
+    /**
+     * Test if the two ranges are touching in any way.
+     */
+    static areIntersectingOrTouching(a: IRange, b: IRange): boolean;
+    /**
+     * Test if the two ranges are intersecting. If the ranges are touching it returns true.
+     */
+    static areIntersecting(a: IRange, b: IRange): boolean;
+    /**
+     * A function that compares ranges, useful for sorting ranges
+     * It will first compare ranges on the startPosition and then on the endPosition
+     */
+    static compareRangesUsingStarts(a: IRange | null | undefined, b: IRange | null | undefined): number;
+    /**
+     * A function that compares ranges, useful for sorting ranges
+     * It will first compare ranges on the endPosition and then on the startPosition
+     */
+    static compareRangesUsingEnds(a: IRange, b: IRange): number;
+    /**
+     * Test if the range spans multiple lines.
+     */
+    static spansMultipleLines(range: IRange): boolean;
+    toJSON(): IRange;
+}
+
+/**
+ * A single edit operation, that acts as a simple replace.
+ * i.e. Replace text at `range` with `text` in model.
+ */
+interface ISingleEditOperation {
+    /**
+     * The range to replace. This can be empty to emulate a simple insert.
+     */
+    range: IRange;
+    /**
+     * The text to replace with. This can be null to emulate a simple delete.
+     */
+    text: string | null;
+    /**
+     * This indicates that this operation has "insert" semantics.
+     * i.e. forceMoveMarkers = true => if `range` is collapsed, all markers at the position will be moved.
+     */
+    forceMoveMarkers?: boolean;
+}
+
+declare class TextChange {
+    readonly oldPosition: number;
+    readonly oldText: string;
+    readonly newPosition: number;
+    readonly newText: string;
+    get oldLength(): number;
+    get oldEnd(): number;
+    get newLength(): number;
+    get newEnd(): number;
+    constructor(oldPosition: number, oldText: string, newPosition: number, newText: string);
+    toString(): string;
+    private static _writeStringSize;
+    private static _writeString;
+    private static _readString;
+    writeSize(): number;
+    write(b: Uint8Array, offset: number): number;
+    static read(b: Uint8Array, offset: number, dest: TextChange[]): number;
+}
+
+/**
+ * A fast character classifier that uses a compact array for ASCII values.
+ */
+declare class CharacterClassifier<T extends number> {
+    /**
+     * Maintain a compact (fully initialized ASCII map for quickly classifying ASCII characters - used more often in code).
+     */
+    protected readonly _asciiMap: Uint8Array;
+    /**
+     * The entire map (sparse array).
+     */
+    protected readonly _map: Map<number, number>;
+    protected readonly _defaultValue: number;
+    constructor(_defaultValue: T);
+    private static _createAsciiMap;
+    set(charCode: number, _value: T): void;
+    get(charCode: number): T;
+    clear(): void;
+}
+
+declare const enum WordCharacterClass {
+    Regular = 0,
+    Whitespace = 1,
+    WordSeparator = 2
+}
+declare class WordCharacterClassifier extends CharacterClassifier<WordCharacterClass> {
+    constructor(wordSeparators: string);
+}
+
+interface IModelContentChange {
+    /**
+     * The range that got replaced.
+     */
+    readonly range: IRange;
+    /**
+     * The offset of the range that got replaced.
+     */
+    readonly rangeOffset: number;
+    /**
+     * The length of the range that got replaced.
+     */
+    readonly rangeLength: number;
+    /**
+     * The new text for the range.
+     */
+    readonly text: string;
+}
+
+/**
+ * End of line character preference.
+ */
+declare const enum EndOfLinePreference {
+    /**
+     * Use the end of line character identified in the text buffer.
+     */
+    TextDefined = 0,
+    /**
+     * Use line feed (\n) as the end of line character.
+     */
+    LF = 1,
+    /**
+     * Use carriage return and line feed (\r\n) as the end of line character.
+     */
+    CRLF = 2
+}
+/**
+ * The default end of line to use when instantiating models.
+ */
+declare const enum DefaultEndOfLine {
+    /**
+     * Use line feed (\n) as the end of line character.
+     */
+    LF = 1,
+    /**
+     * Use carriage return and line feed (\r\n) as the end of line character.
+     */
+    CRLF = 2
+}
+/**
+ * An identifier for a single edit operation.
+ * @internal
+ */
+interface ISingleEditOperationIdentifier {
+    /**
+     * Identifier major
+     */
+    major: number;
+    /**
+     * Identifier minor
+     */
+    minor: number;
+}
+/**
+ * A single edit operation, that has an identifier.
+ */
+interface IIdentifiedSingleEditOperation extends ISingleEditOperation {
+    /**
+     * An identifier associated with this single edit operation.
+     * @internal
+     */
+    identifier?: ISingleEditOperationIdentifier | null;
+    /**
+     * This indicates that this operation is inserting automatic whitespace
+     * that can be removed on next model edit operation if `config.trimAutoWhitespace` is true.
+     * @internal
+     */
+    isAutoWhitespaceEdit?: boolean;
+    /**
+     * This indicates that this operation is in a set of operations that are tracked and should not be "simplified".
+     * @internal
+     */
+    _isTracked?: boolean;
+}
+interface IValidEditOperation {
+    /**
+     * An identifier associated with this single edit operation.
+     * @internal
+     */
+    identifier: ISingleEditOperationIdentifier | null;
+    /**
+     * The range to replace. This can be empty to emulate a simple insert.
+     */
+    range: Range;
+    /**
+     * The text to replace with. This can be empty to emulate a simple delete.
+     */
+    text: string;
+    /**
+     * @internal
+     */
+    textChange: TextChange;
+}
+declare class FindMatch {
+    _findMatchBrand: void;
+    readonly range: Range;
+    readonly matches: string[] | null;
+    /**
+     * @internal
+     */
+    constructor(range: Range, matches: string[] | null);
+}
+/**
+ * Text snapshot that works like an iterator.
+ * Will try to return chunks of roughly ~64KB size.
+ * Will return null when finished.
+ */
+interface ITextSnapshot {
+    read(): string | null;
+}
+/**
+ * A model.
+ */
+type ITextModel = monaco.editor.ITextModel
+/**
+ * @internal
+ */
+interface ITextBufferFactory {
+    create(defaultEOL: DefaultEndOfLine): {
+        textBuffer: ITextBuffer;
+        disposable: IDisposable;
+    };
+    getFirstLineText(lengthLimit: number): string;
+}
+/**
+ * @internal
+ */
+declare class ValidAnnotatedEditOperation implements IIdentifiedSingleEditOperation {
+    readonly identifier: ISingleEditOperationIdentifier | null;
+    readonly range: Range;
+    readonly text: string | null;
+    readonly forceMoveMarkers: boolean;
+    readonly isAutoWhitespaceEdit: boolean;
+    readonly _isTracked: boolean;
+    constructor(identifier: ISingleEditOperationIdentifier | null, range: Range, text: string | null, forceMoveMarkers: boolean, isAutoWhitespaceEdit: boolean, _isTracked: boolean);
+}
+/**
+ * @internal
+ *
+ * `lineNumber` is 1 based.
+ */
+interface IReadonlyTextBuffer {
+    onDidChangeContent: Event<void>;
+    equals(other: ITextBuffer): boolean;
+    mightContainRTL(): boolean;
+    mightContainUnusualLineTerminators(): boolean;
+    resetMightContainUnusualLineTerminators(): void;
+    mightContainNonBasicASCII(): boolean;
+    getBOM(): string;
+    getEOL(): string;
+    getOffsetAt(lineNumber: number, column: number): number;
+    getPositionAt(offset: number): Position;
+    getRangeAt(offset: number, length: number): Range;
+    getValueInRange(range: Range, eol: EndOfLinePreference): string;
+    createSnapshot(preserveBOM: boolean): ITextSnapshot;
+    getValueLengthInRange(range: Range, eol: EndOfLinePreference): number;
+    getCharacterCountInRange(range: Range, eol: EndOfLinePreference): number;
+    getLength(): number;
+    getLineCount(): number;
+    getLinesContent(): string[];
+    getLineContent(lineNumber: number): string;
+    getLineCharCode(lineNumber: number, index: number): number;
+    getCharCode(offset: number): number;
+    getLineLength(lineNumber: number): number;
+    getLineFirstNonWhitespaceColumn(lineNumber: number): number;
+    getLineLastNonWhitespaceColumn(lineNumber: number): number;
+    findMatchesLineByLine(searchRange: Range, searchData: SearchData, captureMatches: boolean, limitResultCount: number): FindMatch[];
+}
+/**
+ * @internal
+ */
+declare class SearchData {
+    /**
+     * The regex to search for. Always defined.
+     */
+    readonly regex: RegExp;
+    /**
+     * The word separator classifier.
+     */
+    readonly wordSeparators: WordCharacterClassifier | null;
+    /**
+     * The simple string to search for (if possible).
+     */
+    readonly simpleSearch: string | null;
+    constructor(regex: RegExp, wordSeparators: WordCharacterClassifier | null, simpleSearch: string | null);
+}
+/**
+ * @internal
+ */
+interface ITextBuffer extends IReadonlyTextBuffer {
+    setEOL(newEOL: '\r\n' | '\n'): void;
+    applyEdits(rawOperations: ValidAnnotatedEditOperation[], recordTrimAutoWhitespace: boolean, computeUndoEdits: boolean): ApplyEditsResult;
+}
+/**
+ * @internal
+ */
+declare class ApplyEditsResult {
+    readonly reverseEdits: IValidEditOperation[] | null;
+    readonly changes: IInternalModelContentChange[];
+    readonly trimAutoWhitespaceLineNumbers: number[] | null;
+    constructor(reverseEdits: IValidEditOperation[] | null, changes: IInternalModelContentChange[], trimAutoWhitespaceLineNumbers: number[] | null);
+}
+/**
+ * @internal
+ */
+interface IInternalModelContentChange extends IModelContentChange {
+    range: Range;
+    forceMoveMarkers: boolean;
+}
+
+/**
+ * A rich code editor.
+ */
+type ICodeEditor = monaco.editor.ICodeEditor
+
+interface IEditorModel {
+    /**
+     * Emitted when the model is about to be disposed.
+     */
+    readonly onWillDispose: Event<void>;
+    /**
+     * Resolves the model.
+     */
+    resolve(): Promise<void>;
+    /**
+     * Find out if the editor model was resolved or not.
+     */
+    isResolved(): boolean;
+    /**
+     * Find out if this model has been disposed.
+     */
+    isDisposed(): boolean;
+    /**
+     * Dispose associated resources
+     */
+    dispose(): void;
+}
+declare enum EditorActivation {
+    /**
+     * Activate the editor after it opened. This will automatically restore
+     * the editor if it is minimized.
+     */
+    ACTIVATE = 1,
+    /**
+     * Only restore the editor if it is minimized but do not activate it.
+     *
+     * Note: will only work in combination with the `preserveFocus: true` option.
+     * Otherwise, if focus moves into the editor, it will activate and restore
+     * automatically.
+     */
+    RESTORE = 2,
+    /**
+     * Preserve the current active editor.
+     *
+     * Note: will only work in combination with the `preserveFocus: true` option.
+     * Otherwise, if focus moves into the editor, it will activate and restore
+     * automatically.
+     */
+    PRESERVE = 3
+}
+declare enum EditorResolution {
+    /**
+     * Displays a picker and allows the user to decide which editor to use.
+     */
+    PICK = 0,
+    /**
+     * Only exclusive editors are considered.
+     */
+    EXCLUSIVE_ONLY = 1
+}
+declare enum EditorOpenSource {
+    /**
+     * Default: the editor is opening via a programmatic call
+     * to the editor service API.
+     */
+    API = 0,
+    /**
+     * Indicates that a user action triggered the opening, e.g.
+     * via mouse or keyboard use.
+     */
+    USER = 1
+}
+interface IEditorOptions {
+    /**
+     * Tells the editor to not receive keyboard focus when the editor is being opened.
+     *
+     * Will also not activate the group the editor opens in unless the group is already
+     * the active one. This behaviour can be overridden via the `activation` option.
+     */
+    preserveFocus?: boolean;
+    /**
+     * This option is only relevant if an editor is opened into a group that is not active
+     * already and allows to control if the inactive group should become active, restored
+     * or preserved.
+     *
+     * By default, the editor group will become active unless `preserveFocus` or `inactive`
+     * is specified.
+     */
+    activation?: EditorActivation;
+    /**
+     * Tells the editor to reload the editor input in the editor even if it is identical to the one
+     * already showing. By default, the editor will not reload the input if it is identical to the
+     * one showing.
+     */
+    forceReload?: boolean;
+    /**
+     * Will reveal the editor if it is already opened and visible in any of the opened editor groups.
+     *
+     * Note that this option is just a hint that might be ignored if the user wants to open an editor explicitly
+     * to the side of another one or into a specific editor group.
+     */
+    revealIfVisible?: boolean;
+    /**
+     * Will reveal the editor if it is already opened (even when not visible) in any of the opened editor groups.
+     *
+     * Note that this option is just a hint that might be ignored if the user wants to open an editor explicitly
+     * to the side of another one or into a specific editor group.
+     */
+    revealIfOpened?: boolean;
+    /**
+     * An editor that is pinned remains in the editor stack even when another editor is being opened.
+     * An editor that is not pinned will always get replaced by another editor that is not pinned.
+     */
+    pinned?: boolean;
+    /**
+     * An editor that is sticky moves to the beginning of the editors list within the group and will remain
+     * there unless explicitly closed. Operations such as "Close All" will not close sticky editors.
+     */
+    sticky?: boolean;
+    /**
+     * The index in the document stack where to insert the editor into when opening.
+     */
+    index?: number;
+    /**
+     * An active editor that is opened will show its contents directly. Set to true to open an editor
+     * in the background without loading its contents.
+     *
+     * Will also not activate the group the editor opens in unless the group is already
+     * the active one. This behaviour can be overridden via the `activation` option.
+     */
+    inactive?: boolean;
+    /**
+     * Will not show an error in case opening the editor fails and thus allows to show a custom error
+     * message as needed. By default, an error will be presented as notification if opening was not possible.
+     */
+    /**
+     * In case of an error opening the editor, will not present this error to the user (e.g. by showing
+     * a generic placeholder in the editor area). So it is up to the caller to provide error information
+     * in that case.
+     *
+     * By default, an error when opening an editor will result in a placeholder editor that shows the error.
+     * In certain cases a modal dialog may be presented to ask the user for further action.
+     */
+    ignoreError?: boolean;
+    /**
+     * Allows to override the editor that should be used to display the input:
+     * - `undefined`: let the editor decide for itself
+     * - `string`: specific override by id
+     * - `EditorResolution`: specific override handling
+     */
+    override?: string | EditorResolution;
+    /**
+     * A optional hint to signal in which context the editor opens.
+     *
+     * If configured to be `EditorOpenSource.USER`, this hint can be
+     * used in various places to control the experience. For example,
+     * if the editor to open fails with an error, a notification could
+     * inform about this in a modal dialog. If the editor opened through
+     * some background task, the notification would show in the background,
+     * not as a modal dialog.
+     */
+    source?: EditorOpenSource;
+    /**
+     * An optional property to signal that certain view state should be
+     * applied when opening the editor.
+     */
+    viewState?: object;
+}
+
+type IEditorOverrideServices = monaco.editor.IEditorOverrideServices
+
+interface ITextEditorModel extends IEditorModel {
+    /**
+     * Provides access to the underlying `ITextModel`.
+     */
+    readonly textEditorModel: ITextModel | null;
+    /**
+     * Creates a snapshot of the model's contents.
+     */
+    createSnapshot(this: IResolvedTextEditorModel): ITextSnapshot;
+    createSnapshot(this: ITextEditorModel): ITextSnapshot | null;
+    /**
+     * Signals if this model is readonly or not.
+     */
+    isReadonly(): boolean;
+    /**
+     * The language id of the text model if known.
+     */
+    getLanguageId(): string | undefined;
+}
+interface IResolvedTextEditorModel extends ITextEditorModel {
+    /**
+     * Same as ITextEditorModel#textEditorModel, but never null.
+     */
+    readonly textEditorModel: ITextModel;
+}
+
+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> {
+}
+
+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 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;
+}
+
+declare const enum SaveReason {
+    /**
+     * Explicit user gesture.
+     */
+    EXPLICIT = 1,
+    /**
+     * Auto save after a timeout.
+     */
+    AUTO = 2,
+    /**
+     * Auto save after editor focus change.
+     */
+    FOCUS_CHANGE = 3,
+    /**
+     * Auto save after window change.
+     */
+    WINDOW_CHANGE = 4
+}
+type SaveSource = string;
+interface ISaveOptions {
+    /**
+     * An indicator how the save operation was triggered.
+     */
+    reason?: SaveReason;
+    /**
+     * An indicator about the source of the save operation.
+     *
+     * Must use `SaveSourceRegistry.registerSource()` to obtain.
+     */
+    readonly source?: SaveSource;
+    /**
+     * Forces to save the contents of the working copy
+     * again even if the working copy is not dirty.
+     */
+    readonly force?: boolean;
+    /**
+     * Instructs the save operation to skip any save participants.
+     */
+    readonly skipSaveParticipants?: boolean;
+    /**
+     * A hint as to which file systems should be available for saving.
+     */
+    readonly availableFileSystems?: string[];
+}
+interface IRevertOptions {
+    /**
+     * Forces to load the contents of the working copy
+     * again even if the working copy is not dirty.
+     */
+    readonly force?: boolean;
+    /**
+     * A soft revert will clear dirty state of a working copy
+     * but will not attempt to load it from its persisted state.
+     *
+     * This option may be used in scenarios where an editor is
+     * closed and where we do not require to load the contents.
+     */
+    readonly soft?: boolean;
+}
+
+declare const enum WorkingCopyCapabilities {
+    /**
+     * Signals no specific capability for the working copy.
+     */
+    None = 0,
+    /**
+     * Signals that the working copy requires
+     * additional input when saving, e.g. an
+     * associated path to save to.
+     */
+    Untitled = 2
+}
+/**
+ * Data to be associated with working copy backups. Use
+ * `IWorkingCopyBackupService.resolve(workingCopy)` to
+ * retrieve the backup when loading the working copy.
+ */
+interface IWorkingCopyBackup {
+    /**
+     * Any serializable metadata to be associated with the backup.
+     */
+    meta?: IWorkingCopyBackupMeta;
+    /**
+     * The actual snapshot of the contents of the working copy at
+     * the time the backup was made.
+     */
+    content?: VSBufferReadable | VSBufferReadableStream;
+}
+/**
+ * Working copy backup metadata that can be associated
+ * with the backup.
+ *
+ * Some properties may be reserved as outlined here and
+ * cannot be used.
+ */
+interface IWorkingCopyBackupMeta {
+    /**
+     * Any property needs to be serializable through JSON.
+     */
+    [key: string]: unknown;
+    /**
+     * `typeId` is a reserved property that cannot be used
+     * as backup metadata.
+     */
+    typeId?: never;
+}
+/**
+ * Every working copy has in common that it is identified by
+ * a resource `URI` and a `typeId`. There can only be one
+ * working copy registered with the same `URI` and `typeId`.
+ */
+interface IWorkingCopyIdentifier {
+    /**
+     * The type identifier of the working copy for grouping
+     * working copies of the same domain together.
+     *
+     * There can only be one working copy for a given resource
+     * and type identifier.
+     */
+    readonly typeId: string;
+    /**
+     * The resource of the working copy must be unique for
+     * working copies of the same `typeId`.
+     */
+    readonly resource: URI;
+}
+interface IWorkingCopySaveEvent {
+    /**
+     * The reason why the working copy was saved.
+     */
+    readonly reason?: SaveReason;
+    /**
+     * The source of the working copy save request.
+     */
+    readonly source?: SaveSource;
+}
+/**
+ * A working copy is an abstract concept to unify handling of
+ * data that can be worked on (e.g. edited) in an editor.
+ *
+ *
+ * A working copy resource may be the backing store of the data
+ * (e.g. a file on disk), but that is not a requirement. If
+ * your working copy is file based, consider to use the
+ * `IFileWorkingCopy` instead that simplifies a lot of things
+ * when working with file based working copies.
+ */
+interface IWorkingCopy extends IWorkingCopyIdentifier {
+    /**
+     * Human readable name of the working copy.
+     */
+    readonly name: string;
+    /**
+     * The capabilities of the working copy.
+     */
+    readonly capabilities: WorkingCopyCapabilities;
+    /**
+     * Used by the workbench to signal if the working copy
+     * is dirty or not. Typically a working copy is dirty
+     * once changed until saved or reverted.
+     */
+    readonly onDidChangeDirty: Event<void>;
+    /**
+     * Used by the workbench e.g. to trigger auto-save
+     * (unless this working copy is untitled) and backups.
+     */
+    readonly onDidChangeContent: Event<void>;
+    /**
+     * Used by the workbench e.g. to track local history
+     * (unless this working copy is untitled).
+     */
+    readonly onDidSave: Event<IWorkingCopySaveEvent>;
+    isDirty(): boolean;
+    /**
+     * The workbench may call this method often after it receives
+     * the `onDidChangeContent` event for the working copy. The motivation
+     * is to allow to quit VSCode with dirty working copies present.
+     *
+     * Providers of working copies should use `IWorkingCopyBackupService.resolve(workingCopy)`
+     * to retrieve the backup metadata associated when loading the working copy.
+     *
+     * @param token support for cancellation
+     */
+    backup(token: CancellationToken): Promise<IWorkingCopyBackup>;
+    /**
+     * Asks the working copy to save. If the working copy was dirty, it is
+     * expected to be non-dirty after this operation has finished.
+     *
+     * @returns `true` if the operation was successful and `false` otherwise.
+     */
+    save(options?: ISaveOptions): Promise<boolean>;
+    /**
+     * Asks the working copy to revert. If the working copy was dirty, it is
+     * expected to be non-dirty after this operation has finished.
+     */
+    revert(options?: IRevertOptions): Promise<void>;
+}
+
+/**
+ * States the text file editor model can be in.
+ */
+declare const enum TextFileEditorModelState {
+    /**
+     * A model is saved.
+     */
+    SAVED = 0,
+    /**
+     * A model is dirty.
+     */
+    DIRTY = 1,
+    /**
+     * A model is currently being saved but this operation has not completed yet.
+     */
+    PENDING_SAVE = 2,
+    /**
+     * A model is in conflict mode when changes cannot be saved because the
+     * underlying file has changed. Models in conflict mode are always dirty.
+     */
+    CONFLICT = 3,
+    /**
+     * A model is in orphan state when the underlying file has been deleted.
+     */
+    ORPHAN = 4,
+    /**
+     * Any error that happens during a save that is not causing the CONFLICT state.
+     * Models in error mode are always dirty.
+     */
+    ERROR = 5
+}
+declare const enum TextFileResolveReason {
+    EDITOR = 1,
+    REFERENCE = 2,
+    OTHER = 3
+}
+interface ITextFileSaveOptions extends ISaveOptions {
+    /**
+     * Save the file with an attempt to unlock it.
+     */
+    readonly writeUnlock?: boolean;
+    /**
+     * Save the file with elevated privileges.
+     *
+     * Note: This may not be supported in all environments.
+     */
+    readonly writeElevated?: boolean;
+    /**
+     * Allows to write to a file even if it has been modified on disk.
+     */
+    readonly ignoreModifiedSince?: boolean;
+    /**
+     * If set, will bubble up the error to the caller instead of handling it.
+     */
+    readonly ignoreErrorHandler?: boolean;
+}
+interface ITextFileResolveOptions {
+    /**
+     * The contents to use for the model if known. If not
+     * provided, the contents will be retrieved from the
+     * underlying resource or backup if present.
+     */
+    readonly contents?: ITextBufferFactory;
+    /**
+     * Go to file bypassing any cache of the model if any.
+     */
+    readonly forceReadFromFile?: boolean;
+    /**
+     * Allow to resolve a model even if we think it is a binary file.
+     */
+    readonly allowBinary?: boolean;
+    /**
+     * Context why the model is being resolved.
+     */
+    readonly reason?: TextFileResolveReason;
+    /**
+     * If provided, the size of the file will be checked against the limits
+     * and an error will be thrown if any limit is exceeded.
+     */
+    readonly limits?: IFileReadLimits;
+}
+declare const enum EncodingMode {
+    /**
+     * Instructs the encoding support to encode the object with the provided encoding
+     */
+    Encode = 0,
+    /**
+     * Instructs the encoding support to decode the object with the provided encoding
+     */
+    Decode = 1
+}
+interface IEncodingSupport {
+    /**
+     * Gets the encoding of the object if known.
+     */
+    getEncoding(): string | undefined;
+    /**
+     * Sets the encoding for the object for saving.
+     */
+    setEncoding(encoding: string, mode: EncodingMode): Promise<void>;
+}
+interface ILanguageSupport {
+    /**
+     * Sets the language id of the object.
+     */
+    setLanguageId(languageId: string, source?: string): void;
+}
+interface ITextFileEditorModelSaveEvent extends IWorkingCopySaveEvent {
+    /**
+     * The resolved stat from the save operation.
+     */
+    readonly stat: IFileStatWithMetadata;
+}
+interface ITextFileEditorModel extends ITextEditorModel, IEncodingSupport, ILanguageSupport, IWorkingCopy {
+    readonly onDidSave: Event<ITextFileEditorModelSaveEvent>;
+    readonly onDidSaveError: Event<void>;
+    readonly onDidChangeOrphaned: Event<void>;
+    readonly onDidChangeReadonly: Event<void>;
+    readonly onDidChangeEncoding: Event<void>;
+    hasState(state: TextFileEditorModelState): boolean;
+    joinState(state: TextFileEditorModelState.PENDING_SAVE): Promise<void>;
+    updatePreferredEncoding(encoding: string | undefined): void;
+    save(options?: ITextFileSaveOptions): Promise<boolean>;
+    revert(options?: IRevertOptions): Promise<void>;
+    resolve(options?: ITextFileResolveOptions): Promise<void>;
+    isDirty(): this is IResolvedTextFileEditorModel;
+    getLanguageId(): string | undefined;
+    isResolved(): this is IResolvedTextFileEditorModel;
+}
+interface IResolvedTextFileEditorModel extends ITextFileEditorModel {
     readonly textEditorModel: ITextModel;
+    createSnapshot(): ITextSnapshot;
 }
 
 type OpenEditor = (modelRef: IReference<IResolvedTextEditorModel>, options: IEditorOptions | undefined, sideBySide?: boolean) => Promise<ICodeEditor | undefined>;
 declare function getServiceOverride(openEditor: OpenEditor): IEditorOverrideServices;
 
-export { IEditorOptions, IReference, IResolvedTextEditorModel, OpenEditor, getServiceOverride as default };
+export { IEditorOptions, IReference, IResolvedTextEditorModel, ITextFileEditorModel, OpenEditor, getServiceOverride as default };