@codingame/monaco-vscode-api 1.78.2 → 1.78.3-next.0

package/dist/modelEditor.d.ts

@@ -48,27 +48,6 @@ 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;
     /**
@@ -368,1457 +347,216 @@ declare namespace Event {
 }
 
 /**
- * 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
- * ```
+ * Text snapshot that works like an iterator.
+ * Will try to return chunks of roughly ~64KB size.
+ * Will return null when finished.
  */
-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 ITextSnapshot {
+    read(): string | null;
 }
-
 /**
- * A position in the editor. This interface is suitable for serialization.
+ * A model.
  */
-interface IPosition {
-    /**
-     * line number (starts at 1)
-     */
-    readonly lineNumber: number;
-    /**
-     * column (the first character in a line is between column 1 and column 2)
-     */
-    readonly column: number;
-}
+type ITextModel = monaco.editor.ITextModel
+
 /**
- * A position in the editor.
+ * A rich code editor.
  */
-declare class Position {
-    /**
-     * line number (starts at 1)
-     */
-    readonly lineNumber: number;
-    /**
-     * column (the first character in a line is between column 1 and column 2)
-     */
-    readonly column: number;
-    constructor(lineNumber: number, column: number);
-    /**
-     * Create a new position from this position.
-     *
-     * @param newLineNumber new line number
-     * @param newColumn new column
-     */
-    with(newLineNumber?: number, newColumn?: number): Position;
-    /**
-     * Derive a new position from this position.
-     *
-     * @param deltaLineNumber line number delta
-     * @param deltaColumn column delta
-     */
-    delta(deltaLineNumber?: number, deltaColumn?: number): Position;
-    /**
-     * Test if this position equals other position
-     */
-    equals(other: IPosition): boolean;
-    /**
-     * Test if position `a` equals position `b`
-     */
-    static equals(a: IPosition | null, b: IPosition | null): boolean;
-    /**
-     * Test if this position is before other position.
-     * If the two positions are equal, the result will be false.
-     */
-    isBefore(other: IPosition): boolean;
-    /**
-     * Test if position `a` is before position `b`.
-     * If the two positions are equal, the result will be false.
-     */
-    static isBefore(a: IPosition, b: IPosition): boolean;
-    /**
-     * Test if this position is before other position.
-     * If the two positions are equal, the result will be true.
-     */
-    isBeforeOrEqual(other: IPosition): boolean;
-    /**
-     * 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;
+type ICodeEditor = monaco.editor.ICodeEditor
+
+interface IEditorModel {
     /**
-     * A function that compares positions, useful for sorting
+     * Emitted when the model is about to be disposed.
      */
-    static compare(a: IPosition, b: IPosition): number;
+    readonly onWillDispose: Event<void>;
     /**
-     * Clone this position.
+     * Resolves the model.
      */
-    clone(): Position;
+    resolve(): Promise<void>;
     /**
-     * Convert to a human-readable representation.
+     * Find out if the editor model was resolved or not.
      */
-    toString(): string;
+    isResolved(): boolean;
     /**
-     * Create a `Position` from an `IPosition`.
+     * Find out if this model has been disposed.
      */
-    static lift(pos: IPosition): Position;
+    isDisposed(): boolean;
     /**
-     * Test if `obj` is an `IPosition`.
+     * Dispose associated resources
      */
-    static isIPosition(obj: any): obj is IPosition;
+    dispose(): void;
 }
-
-/**
- * A range in the editor. This interface is suitable for serialization.
- */
-interface IRange {
-    /**
-     * Line number on which the range starts (starts at 1).
-     */
-    readonly startLineNumber: number;
+declare enum EditorActivation {
     /**
-     * Column on which the range starts in line `startLineNumber` (starts at 1).
+     * Activate the editor after it opened. This will automatically restore
+     * the editor if it is minimized.
      */
-    readonly startColumn: number;
+    ACTIVATE = 1,
     /**
-     * Line number on which the range ends.
+     * 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.
      */
-    readonly endLineNumber: number;
+    RESTORE = 2,
     /**
-     * Column on which the range ends in line `endLineNumber`.
+     * 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.
      */
-    readonly endColumn: number;
+    PRESERVE = 3
 }
-/**
- * A range in the editor. (startLineNumber,startColumn) is <= (endLineNumber,endColumn)
- */
-declare class Range {
-    /**
-     * 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;
+declare enum EditorResolution {
     /**
-     * A intersection of the two ranges.
+     * Displays a picker and allows the user to decide which editor to use.
      */
-    static intersectRanges(a: IRange, b: IRange): Range | null;
+    PICK = 0,
     /**
-     * Test if this range equals other.
+     * Only exclusive editors are considered.
      */
-    equalsRange(other: IRange | null | undefined): boolean;
+    EXCLUSIVE_ONLY = 1
+}
+declare enum EditorOpenSource {
     /**
-     * Test if range `a` equals `b`.
+     * Default: the editor is opening via a programmatic call
+     * to the editor service API.
      */
-    static equalsRange(a: IRange | null | undefined, b: IRange | null | undefined): boolean;
+    API = 0,
     /**
-     * Return the end position (which will be after or equal to the start position)
+     * Indicates that a user action triggered the opening, e.g.
+     * via mouse or keyboard use.
      */
-    getEndPosition(): Position;
+    USER = 1
+}
+interface IEditorOptions {
     /**
-     * Return the end position (which will be after or equal to the start 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.
      */
-    static getEndPosition(range: IRange): Position;
+    preserveFocus?: boolean;
     /**
-     * Return the start position (which will be before or equal to the end position)
+     * 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.
      */
-    getStartPosition(): Position;
+    activation?: EditorActivation;
     /**
-     * Return the start position (which will be before or equal to the end position)
+     * 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.
      */
-    static getStartPosition(range: IRange): Position;
+    forceReload?: boolean;
     /**
-     * Transform to a user presentable string representation.
+     * 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.
      */
-    toString(): string;
+    revealIfVisible?: boolean;
     /**
-     * Create a new range using this range's start position, and using endLineNumber and endColumn as the end 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.
      */
-    setEndPosition(endLineNumber: number, endColumn: number): Range;
+    revealIfOpened?: boolean;
     /**
-     * Create a new range using this range's end position, and using startLineNumber and startColumn as the start position.
+     * 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.
      */
-    setStartPosition(startLineNumber: number, startColumn: number): Range;
+    pinned?: boolean;
     /**
-     * Create a new empty range using this range's start position.
+     * 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.
      */
-    collapseToStart(): Range;
+    sticky?: boolean;
     /**
-     * Create a new empty range using this range's start position.
+     * The index in the document stack where to insert the editor into when opening.
      */
-    static collapseToStart(range: IRange): Range;
+    index?: number;
     /**
-     * Create a new empty range using this range's end position.
+     * 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.
      */
-    collapseToEnd(): Range;
+    inactive?: boolean;
     /**
-     * Create a new empty range using this range's end position.
+     * 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.
      */
-    static collapseToEnd(range: IRange): Range;
     /**
-     * Moves the range by the given amount of lines.
+     * 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.
      */
-    delta(lineCount: number): Range;
-    static fromPositions(start: IPosition, end?: IPosition): Range;
+    ignoreError?: boolean;
     /**
-     * Create a `Range` from an `IRange`.
+     * 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
      */
-    static lift(range: undefined | null): null;
-    static lift(range: IRange): Range;
-    static lift(range: IRange | undefined | null): Range | null;
+    override?: string | EditorResolution;
     /**
-     * Test if `obj` is an `IRange`.
+     * 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.
      */
-    static isIRange(obj: any): obj is IRange;
+    source?: EditorOpenSource;
     /**
-     * Test if the two ranges are touching in any way.
+     * An optional property to signal that certain view state should be
+     * applied when opening the editor.
      */
-    static areIntersectingOrTouching(a: IRange, b: IRange): boolean;
+    viewState?: object;
+}
+
+type IEditorOverrideServices = monaco.editor.IEditorOverrideServices
+
+interface ITextEditorModel extends IEditorModel {
     /**
-     * Test if the two ranges are intersecting. If the ranges are touching it returns true.
+     * Provides access to the underlying `ITextModel`.
      */
-    static areIntersecting(a: IRange, b: IRange): boolean;
+    readonly textEditorModel: ITextModel | null;
     /**
-     * A function that compares ranges, useful for sorting ranges
-     * It will first compare ranges on the startPosition and then on the endPosition
+     * Creates a snapshot of the model's contents.
      */
-    static compareRangesUsingStarts(a: IRange | null | undefined, b: IRange | null | undefined): number;
+    createSnapshot(this: IResolvedTextEditorModel): ITextSnapshot;
+    createSnapshot(this: ITextEditorModel): ITextSnapshot | null;
     /**
-     * A function that compares ranges, useful for sorting ranges
-     * It will first compare ranges on the endPosition and then on the startPosition
+     * Signals if this model is readonly or not.
      */
-    static compareRangesUsingEnds(a: IRange, b: IRange): number;
+    isReadonly(): boolean;
     /**
-     * Test if the range spans multiple lines.
+     * The language id of the text model if known.
      */
-    static spansMultipleLines(range: IRange): boolean;
-    toJSON(): IRange;
+    getLanguageId(): string | undefined;
 }
-
-/**
- * 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;
+interface IResolvedTextEditorModel extends ITextEditorModel {
     /**
-     * This indicates that this operation has "insert" semantics.
-     * i.e. forceMoveMarkers = true => if `range` is collapsed, all markers at the position will be moved.
+     * Same as ITextEditorModel#textEditorModel, but never null.
      */
-    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, ITextFileEditorModel, OpenEditor, getServiceOverride as default };
+export { IEditorOptions, IReference, IResolvedTextEditorModel, OpenEditor, getServiceOverride as default };