@codingame/monaco-vscode-api 1.78.8 → 1.79.0

package/dist/editorBrowser.d.ts

@@ -0,0 +1,3128 @@
+import { S as ServiceIdentifier } from './instantiation.js';
+import { I as IDisposable, E as Event, a as IReference } from './event.js';
+import { a as UriComponents, U as URI } from './uri.js';
+import { I as IMarkdownString, e as IEditorModel$1 } from './editor.js';
+import * as monaco from 'monaco-editor';
+import { a as ThemeColor } from './themables.js';
+
+/**
+ * A position in the editor. This interface is suitable for serialization.
+ */
+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;
+}
+/**
+ * A position in the 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;
+    /**
+     * A function that compares positions, useful for sorting
+     */
+    static compare(a: IPosition, b: IPosition): number;
+    /**
+     * Clone this position.
+     */
+    clone(): Position;
+    /**
+     * Convert to a human-readable representation.
+     */
+    toString(): string;
+    /**
+     * Create a `Position` from an `IPosition`.
+     */
+    static lift(pos: IPosition): Position;
+    /**
+     * Test if `obj` is an `IPosition`.
+     */
+    static isIPosition(obj: any): obj is IPosition;
+}
+
+/**
+ * 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;
+    /**
+     * 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;
+}
+/**
+ * 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;
+    /**
+     * 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 range of lines (1-based).
+ */
+declare class LineRange {
+    /**
+     * @param lineRanges An array of sorted line ranges.
+     */
+    static joinMany(lineRanges: readonly (readonly LineRange[])[]): readonly LineRange[];
+    /**
+     * @param lineRanges1 Must be sorted.
+     * @param lineRanges2 Must be sorted.
+     */
+    static join(lineRanges1: readonly LineRange[], lineRanges2: readonly LineRange[]): readonly LineRange[];
+    /**
+     * The start line number.
+     */
+    readonly startLineNumber: number;
+    /**
+     * The end line number (exclusive).
+     */
+    readonly endLineNumberExclusive: number;
+    constructor(startLineNumber: number, endLineNumberExclusive: number);
+    /**
+     * Indicates if this line range contains the given line number.
+     */
+    contains(lineNumber: number): boolean;
+    /**
+     * Indicates if this line range is empty.
+     */
+    get isEmpty(): boolean;
+    /**
+     * Moves this line range by the given offset of line numbers.
+     */
+    delta(offset: number): LineRange;
+    /**
+     * The number of lines this line range spans.
+     */
+    get length(): number;
+    /**
+     * Creates a line range that combines this and the given line range.
+     */
+    join(other: LineRange): LineRange;
+    toString(): string;
+    /**
+     * The resulting range is empty if the ranges do not intersect, but touch.
+     * If the ranges don't even touch, the result is undefined.
+     */
+    intersect(other: LineRange): LineRange | undefined;
+    overlapOrTouch(other: LineRange): boolean;
+    equals(b: LineRange): boolean;
+}
+
+/**
+ * Maps a line range in the original text model to a line range in the modified text model.
+ */
+declare class LineRangeMapping {
+    /**
+     * The line range in the original text model.
+     */
+    readonly originalRange: LineRange;
+    /**
+     * The line range in the modified text model.
+     */
+    readonly modifiedRange: LineRange;
+    /**
+     * If inner changes have not been computed, this is set to undefined.
+     * Otherwise, it represents the character-level diff in this line range.
+     * The original range of each range mapping should be contained in the original line range (same for modified), exceptions are new-lines.
+     * Must not be an empty array.
+     */
+    readonly innerChanges: RangeMapping[] | undefined;
+    constructor(originalRange: LineRange, modifiedRange: LineRange, innerChanges: RangeMapping[] | undefined);
+    toString(): string;
+    get changedLineCount(): number;
+}
+/**
+ * Maps a range in the original text model to a range in the modified text model.
+ */
+declare class RangeMapping {
+    /**
+     * The original range.
+     */
+    readonly originalRange: Range;
+    /**
+     * The modified range.
+     */
+    readonly modifiedRange: Range;
+    constructor(originalRange: Range, modifiedRange: Range);
+    toString(): string;
+}
+
+/**
+ * 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;
+}
+
+/**
+ * A selection in the editor.
+ * The selection is a range that has an orientation.
+ */
+interface ISelection {
+    /**
+     * The line number on which the selection has started.
+     */
+    readonly selectionStartLineNumber: number;
+    /**
+     * The column on `selectionStartLineNumber` where the selection has started.
+     */
+    readonly selectionStartColumn: number;
+    /**
+     * The line number on which the selection has ended.
+     */
+    readonly positionLineNumber: number;
+    /**
+     * The column on `positionLineNumber` where the selection has ended.
+     */
+    readonly positionColumn: number;
+}
+/**
+ * The direction of a selection.
+ */
+declare const enum SelectionDirection {
+    /**
+     * The selection starts above where it ends.
+     */
+    LTR = 0,
+    /**
+     * The selection starts below where it ends.
+     */
+    RTL = 1
+}
+/**
+ * A selection in the editor.
+ * The selection is a range that has an orientation.
+ */
+declare class Selection extends Range {
+    /**
+     * The line number on which the selection has started.
+     */
+    readonly selectionStartLineNumber: number;
+    /**
+     * The column on `selectionStartLineNumber` where the selection has started.
+     */
+    readonly selectionStartColumn: number;
+    /**
+     * The line number on which the selection has ended.
+     */
+    readonly positionLineNumber: number;
+    /**
+     * The column on `positionLineNumber` where the selection has ended.
+     */
+    readonly positionColumn: number;
+    constructor(selectionStartLineNumber: number, selectionStartColumn: number, positionLineNumber: number, positionColumn: number);
+    /**
+     * Transform to a human-readable representation.
+     */
+    toString(): string;
+    /**
+     * Test if equals other selection.
+     */
+    equalsSelection(other: ISelection): boolean;
+    /**
+     * Test if the two selections are equal.
+     */
+    static selectionsEqual(a: ISelection, b: ISelection): boolean;
+    /**
+     * Get directions (LTR or RTL).
+     */
+    getDirection(): SelectionDirection;
+    /**
+     * Create a new selection with a different `positionLineNumber` and `positionColumn`.
+     */
+    setEndPosition(endLineNumber: number, endColumn: number): Selection;
+    /**
+     * Get the position at `positionLineNumber` and `positionColumn`.
+     */
+    getPosition(): Position;
+    /**
+     * Get the position at the start of the selection.
+    */
+    getSelectionStart(): Position;
+    /**
+     * Create a new selection with a different `selectionStartLineNumber` and `selectionStartColumn`.
+     */
+    setStartPosition(startLineNumber: number, startColumn: number): Selection;
+    /**
+     * Create a `Selection` from one or two positions
+     */
+    static fromPositions(start: IPosition, end?: IPosition): Selection;
+    /**
+     * Creates a `Selection` from a range, given a direction.
+     */
+    static fromRange(range: Range, direction: SelectionDirection): Selection;
+    /**
+     * Create a `Selection` from an `ISelection`.
+     */
+    static liftSelection(sel: ISelection): Selection;
+    /**
+     * `a` equals `b`.
+     */
+    static selectionsArrEqual(a: ISelection[], b: ISelection[]): boolean;
+    /**
+     * Test if `obj` is an `ISelection`.
+     */
+    static isISelection(obj: any): obj is ISelection;
+    /**
+     * Create with a direction.
+     */
+    static createWithDirection(startLineNumber: number, startColumn: number, endLineNumber: number, endColumn: number, direction: SelectionDirection): Selection;
+}
+
+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;
+}
+/**
+ * An event describing that model decorations have changed.
+ */
+interface IModelDecorationsChangedEvent {
+    readonly affectsMinimap: boolean;
+    readonly affectsOverviewRuler: boolean;
+    readonly affectsGlyphMargin: boolean;
+}
+
+/**
+ * Vertical Lane in the overview ruler of the editor.
+ */
+declare enum OverviewRulerLane {
+    Left = 1,
+    Center = 2,
+    Right = 4,
+    Full = 7
+}
+/**
+ * Vertical Lane in the glyph margin of the editor.
+ */
+declare enum GlyphMarginLane {
+    Left = 1,
+    Right = 2
+}
+/**
+ * Position in the minimap to render the decoration.
+ */
+declare enum MinimapPosition {
+    Inline = 1,
+    Gutter = 2
+}
+interface IDecorationOptions {
+    /**
+     * CSS color to render.
+     * e.g.: rgba(100, 100, 100, 0.5) or a color from the color registry
+     */
+    color: string | ThemeColor | undefined;
+    /**
+     * CSS color to render.
+     * e.g.: rgba(100, 100, 100, 0.5) or a color from the color registry
+     */
+    darkColor?: string | ThemeColor;
+}
+interface IModelDecorationGlyphMarginOptions {
+    /**
+     * The position in the glyph margin.
+     */
+    position: GlyphMarginLane;
+}
+/**
+ * Options for rendering a model decoration in the overview ruler.
+ */
+interface IModelDecorationOverviewRulerOptions extends IDecorationOptions {
+    /**
+     * The position in the overview ruler.
+     */
+    position: OverviewRulerLane;
+}
+/**
+ * Options for rendering a model decoration in the minimap.
+ */
+interface IModelDecorationMinimapOptions extends IDecorationOptions {
+    /**
+     * The position in the minimap.
+     */
+    position: MinimapPosition;
+}
+/**
+ * Options for a model decoration.
+ */
+interface IModelDecorationOptions {
+    /**
+     * A debug description that can be used for inspecting model decorations.
+     * @internal
+     */
+    description: string;
+    /**
+     * Customize the growing behavior of the decoration when typing at the edges of the decoration.
+     * Defaults to TrackedRangeStickiness.AlwaysGrowsWhenTypingAtEdges
+     */
+    stickiness?: TrackedRangeStickiness;
+    /**
+     * CSS class name describing the decoration.
+     */
+    className?: string | null;
+    blockClassName?: string | null;
+    /**
+     * Indicates if this block should be rendered after the last line.
+     * In this case, the range must be empty and set to the last line.
+     */
+    blockIsAfterEnd?: boolean | null;
+    blockDoesNotCollapse?: boolean | null;
+    blockPadding?: [top: number, right: number, bottom: number, left: number] | null;
+    /**
+     * Message to be rendered when hovering over the glyph margin decoration.
+     */
+    glyphMarginHoverMessage?: IMarkdownString | IMarkdownString[] | null;
+    /**
+     * Array of MarkdownString to render as the decoration message.
+     */
+    hoverMessage?: IMarkdownString | IMarkdownString[] | null;
+    /**
+     * Should the decoration expand to encompass a whole line.
+     */
+    isWholeLine?: boolean;
+    /**
+     * Always render the decoration (even when the range it encompasses is collapsed).
+     */
+    showIfCollapsed?: boolean;
+    /**
+     * Collapse the decoration if its entire range is being replaced via an edit.
+     * @internal
+     */
+    collapseOnReplaceEdit?: boolean;
+    /**
+     * Specifies the stack order of a decoration.
+     * A decoration with greater stack order is always in front of a decoration with
+     * a lower stack order when the decorations are on the same line.
+     */
+    zIndex?: number;
+    /**
+     * If set, render this decoration in the overview ruler.
+     */
+    overviewRuler?: IModelDecorationOverviewRulerOptions | null;
+    /**
+     * If set, render this decoration in the minimap.
+     */
+    minimap?: IModelDecorationMinimapOptions | null;
+    /**
+     * If set, the decoration will be rendered in the glyph margin with this CSS class name.
+     */
+    glyphMarginClassName?: string | null;
+    /**
+     * If set and the decoration has {@link glyphMarginClassName} set, render this decoration
+     * with the specified {@link IModelDecorationGlyphMarginOptions} in the glyph margin.
+     */
+    glyphMargin?: IModelDecorationGlyphMarginOptions | null;
+    /**
+     * If set, the decoration will be rendered in the lines decorations with this CSS class name.
+     */
+    linesDecorationsClassName?: string | null;
+    /**
+     * If set, the decoration will be rendered in the lines decorations with this CSS class name, but only for the first line in case of line wrapping.
+     */
+    firstLineDecorationClassName?: string | null;
+    /**
+     * If set, the decoration will be rendered in the margin (covering its full width) with this CSS class name.
+     */
+    marginClassName?: string | null;
+    /**
+     * If set, the decoration will be rendered inline with the text with this CSS class name.
+     * Please use this only for CSS rules that must impact the text. For example, use `className`
+     * to have a background color decoration.
+     */
+    inlineClassName?: string | null;
+    /**
+     * If there is an `inlineClassName` which affects letter spacing.
+     */
+    inlineClassNameAffectsLetterSpacing?: boolean;
+    /**
+     * If set, the decoration will be rendered before the text with this CSS class name.
+     */
+    beforeContentClassName?: string | null;
+    /**
+     * If set, the decoration will be rendered after the text with this CSS class name.
+     */
+    afterContentClassName?: string | null;
+    /**
+     * If set, text will be injected in the view after the range.
+     */
+    after?: InjectedTextOptions | null;
+    /**
+     * If set, text will be injected in the view before the range.
+     */
+    before?: InjectedTextOptions | null;
+    /**
+     * If set, this decoration will not be rendered for comment tokens.
+     * @internal
+    */
+    hideInCommentTokens?: boolean | null;
+    /**
+     * If set, this decoration will not be rendered for string tokens.
+     * @internal
+    */
+    hideInStringTokens?: boolean | null;
+}
+/**
+ * Configures text that is injected into the view without changing the underlying document.
+*/
+interface InjectedTextOptions {
+    /**
+     * Sets the text to inject. Must be a single line.
+     */
+    readonly content: string;
+    /**
+     * If set, the decoration will be rendered inline with the text with this CSS class name.
+     */
+    readonly inlineClassName?: string | null;
+    /**
+     * If there is an `inlineClassName` which affects letter spacing.
+     */
+    readonly inlineClassNameAffectsLetterSpacing?: boolean;
+    /**
+     * This field allows to attach data to this injected text.
+     * The data can be read when injected texts at a given position are queried.
+     */
+    readonly attachedData?: unknown;
+    /**
+     * Configures cursor stops around injected text.
+     * Defaults to {@link InjectedTextCursorStops.Both}.
+    */
+    readonly cursorStops?: InjectedTextCursorStops | null;
+}
+declare enum InjectedTextCursorStops {
+    Both = 0,
+    Right = 1,
+    Left = 2,
+    None = 3
+}
+/**
+ * New model decorations.
+ */
+interface IModelDeltaDecoration {
+    /**
+     * Range that this decoration covers.
+     */
+    range: IRange;
+    /**
+     * Options associated with this decoration.
+     */
+    options: IModelDecorationOptions;
+}
+/**
+ * A decoration in the model.
+ */
+interface IModelDecoration {
+    /**
+     * Identifier for a decoration.
+     */
+    readonly id: string;
+    /**
+     * Identifier for a decoration's owner.
+     */
+    readonly ownerId: number;
+    /**
+     * Range that this decoration covers.
+     */
+    readonly range: Range;
+    /**
+     * Options associated with this decoration.
+     */
+    readonly options: IModelDecorationOptions;
+}
+/**
+ * An accessor that can add, change or remove model decorations.
+ * @internal
+ */
+interface IModelDecorationsChangeAccessor {
+    /**
+     * Add a new decoration.
+     * @param range Range that this decoration covers.
+     * @param options Options associated with this decoration.
+     * @return An unique identifier associated with this decoration.
+     */
+    addDecoration(range: IRange, options: IModelDecorationOptions): string;
+    /**
+     * Change the range that an existing decoration covers.
+     * @param id The unique identifier associated with the decoration.
+     * @param newRange The new range that this decoration covers.
+     */
+    changeDecoration(id: string, newRange: IRange): void;
+    /**
+     * Change the options associated with an existing decoration.
+     * @param id The unique identifier associated with the decoration.
+     * @param newOptions The new options associated with this decoration.
+     */
+    changeDecorationOptions(id: string, newOptions: IModelDecorationOptions): void;
+    /**
+     * Remove an existing decoration.
+     * @param id The unique identifier associated with the decoration.
+     */
+    removeDecoration(id: string): void;
+    /**
+     * Perform a minimum amount of operations, in order to transform the decorations
+     * identified by `oldDecorations` to the decorations described by `newDecorations`
+     * and returns the new identifiers associated with the resulting decorations.
+     *
+     * @param oldDecorations Array containing previous decorations identifiers.
+     * @param newDecorations Array describing what decorations should result after the call.
+     * @return An array containing the new decorations identifiers.
+     */
+    deltaDecorations(oldDecorations: readonly string[], newDecorations: readonly IModelDeltaDecoration[]): 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
+}
+/**
+ * End of line character preference.
+ */
+declare const enum EndOfLineSequence {
+    /**
+     * Use line feed (\n) as the end of line character.
+     */
+    LF = 0,
+    /**
+     * Use carriage return and line feed (\r\n) as the end of line character.
+     */
+    CRLF = 1
+}
+/**
+ * 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;
+}
+/**
+ * @internal
+ */
+interface ITextModelCreationOptions {
+    tabSize: number;
+    indentSize: number | 'tabSize';
+    insertSpaces: boolean;
+    detectIndentation: boolean;
+    trimAutoWhitespace: boolean;
+    defaultEOL: DefaultEndOfLine;
+    isForSimpleWidget: boolean;
+    largeFileOptimizations: boolean;
+    bracketPairColorizationOptions: BracketPairColorizationOptions;
+}
+interface BracketPairColorizationOptions {
+    enabled: boolean;
+    independentColorPoolPerBracketType: boolean;
+}
+declare class FindMatch {
+    _findMatchBrand: void;
+    readonly range: Range;
+    readonly matches: string[] | null;
+    /**
+     * @internal
+     */
+    constructor(range: Range, matches: string[] | null);
+}
+/**
+ * Describes the behavior of decorations when typing/editing near their edges.
+ * Note: Please do not edit the values, as they very carefully match `DecorationRangeBehavior`
+ */
+declare const enum TrackedRangeStickiness {
+    AlwaysGrowsWhenTypingAtEdges = 0,
+    NeverGrowsWhenTypingAtEdges = 1,
+    GrowsOnlyWhenTypingBefore = 2,
+    GrowsOnlyWhenTypingAfter = 3
+}
+/**
+ * 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 document diff provider computes the diff between two text models.
+ */
+interface IDocumentDiffProvider {
+    /**
+     * Computes the diff between the text models `original` and `modified`.
+     */
+    computeDiff(original: ITextModel, modified: ITextModel, options: IDocumentDiffProviderOptions): Promise<IDocumentDiff>;
+    /**
+     * Is fired when settings of the diff algorithm change that could alter the result of the diffing computation.
+     * Any user of this provider should recompute the diff when this event is fired.
+     */
+    onDidChange: Event<void>;
+}
+/**
+ * Options for the diff computation.
+ */
+interface IDocumentDiffProviderOptions {
+    /**
+     * When set to true, the diff should ignore whitespace changes.i
+     */
+    ignoreTrimWhitespace: boolean;
+    /**
+     * A diff computation should throw if it takes longer than this value.
+     */
+    maxComputationTimeMs: number;
+}
+/**
+ * Represents a diff between two text models.
+ */
+interface IDocumentDiff {
+    /**
+     * If true, both text models are identical (byte-wise).
+     */
+    readonly identical: boolean;
+    /**
+     * If true, the diff computation timed out and the diff might not be accurate.
+     */
+    readonly quitEarly: boolean;
+    /**
+     * Maps all modified line ranges in the original to the corresponding line ranges in the modified text model.
+     */
+    readonly changes: LineRangeMapping[];
+}
+
+/**
+ * Configuration options for auto closing quotes and brackets
+ */
+type EditorAutoClosingStrategy = 'always' | 'languageDefined' | 'beforeWhitespace' | 'never';
+/**
+ * Configuration options for auto wrapping quotes and brackets
+ */
+type EditorAutoSurroundStrategy = 'languageDefined' | 'quotes' | 'brackets' | 'never';
+/**
+ * Configuration options for typing over closing quotes or brackets
+ */
+type EditorAutoClosingEditStrategy = 'always' | 'auto' | 'never';
+/**
+ * Configuration options for auto indentation in the editor
+ */
+declare const enum EditorAutoIndentStrategy {
+    None = 0,
+    Keep = 1,
+    Brackets = 2,
+    Advanced = 3,
+    Full = 4
+}
+/**
+ * Configuration options for the editor.
+ */
+interface IEditorOptions {
+    /**
+     * This editor is used inside a diff editor.
+     */
+    inDiffEditor?: boolean;
+    /**
+     * The aria label for the editor's textarea (when it is focused).
+     */
+    ariaLabel?: string;
+    /**
+     * Control whether a screen reader announces inline suggestion content immediately.
+     */
+    screenReaderAnnounceInlineSuggestion?: boolean;
+    /**
+     * The `tabindex` property of the editor's textarea
+     */
+    tabIndex?: number;
+    /**
+     * Render vertical lines at the specified columns.
+     * Defaults to empty array.
+     */
+    rulers?: (number | IRulerOption)[];
+    /**
+     * A string containing the word separators used when doing word navigation.
+     * Defaults to `~!@#$%^&*()-=+[{]}\\|;:\'",.<>/?
+     */
+    wordSeparators?: string;
+    /**
+     * Enable Linux primary clipboard.
+     * Defaults to true.
+     */
+    selectionClipboard?: boolean;
+    /**
+     * Control the rendering of line numbers.
+     * If it is a function, it will be invoked when rendering a line number and the return value will be rendered.
+     * Otherwise, if it is a truthy, line numbers will be rendered normally (equivalent of using an identity function).
+     * Otherwise, line numbers will not be rendered.
+     * Defaults to `on`.
+     */
+    lineNumbers?: LineNumbersType;
+    /**
+     * Controls the minimal number of visible leading and trailing lines surrounding the cursor.
+     * Defaults to 0.
+    */
+    cursorSurroundingLines?: number;
+    /**
+     * Controls when `cursorSurroundingLines` should be enforced
+     * Defaults to `default`, `cursorSurroundingLines` is not enforced when cursor position is changed
+     * by mouse.
+    */
+    cursorSurroundingLinesStyle?: 'default' | 'all';
+    /**
+     * Render last line number when the file ends with a newline.
+     * Defaults to 'on' for Windows and macOS and 'dimmed' for Linux.
+    */
+    renderFinalNewline?: 'on' | 'off' | 'dimmed';
+    /**
+     * Remove unusual line terminators like LINE SEPARATOR (LS), PARAGRAPH SEPARATOR (PS).
+     * Defaults to 'prompt'.
+     */
+    unusualLineTerminators?: 'auto' | 'off' | 'prompt';
+    /**
+     * Should the corresponding line be selected when clicking on the line number?
+     * Defaults to true.
+     */
+    selectOnLineNumbers?: boolean;
+    /**
+     * Control the width of line numbers, by reserving horizontal space for rendering at least an amount of digits.
+     * Defaults to 5.
+     */
+    lineNumbersMinChars?: number;
+    /**
+     * Enable the rendering of the glyph margin.
+     * Defaults to true in vscode and to false in monaco-editor.
+     */
+    glyphMargin?: boolean;
+    /**
+     * The width reserved for line decorations (in px).
+     * Line decorations are placed between line numbers and the editor content.
+     * You can pass in a string in the format floating point followed by "ch". e.g. 1.3ch.
+     * Defaults to 10.
+     */
+    lineDecorationsWidth?: number | string;
+    /**
+     * When revealing the cursor, a virtual padding (px) is added to the cursor, turning it into a rectangle.
+     * This virtual padding ensures that the cursor gets revealed before hitting the edge of the viewport.
+     * Defaults to 30 (px).
+     */
+    revealHorizontalRightPadding?: number;
+    /**
+     * Render the editor selection with rounded borders.
+     * Defaults to true.
+     */
+    roundedSelection?: boolean;
+    /**
+     * Class name to be added to the editor.
+     */
+    extraEditorClassName?: string;
+    /**
+     * Should the editor be read only. See also `domReadOnly`.
+     * Defaults to false.
+     */
+    readOnly?: boolean;
+    /**
+     * Should the textarea used for input use the DOM `readonly` attribute.
+     * Defaults to false.
+     */
+    domReadOnly?: boolean;
+    /**
+     * Enable linked editing.
+     * Defaults to false.
+     */
+    linkedEditing?: boolean;
+    /**
+     * deprecated, use linkedEditing instead
+     */
+    renameOnType?: boolean;
+    /**
+     * Should the editor render validation decorations.
+     * Defaults to editable.
+     */
+    renderValidationDecorations?: 'editable' | 'on' | 'off';
+    /**
+     * Control the behavior and rendering of the scrollbars.
+     */
+    scrollbar?: IEditorScrollbarOptions;
+    /**
+     * Control the behavior of sticky scroll options
+     */
+    stickyScroll?: IEditorStickyScrollOptions;
+    /**
+     * Control the behavior and rendering of the minimap.
+     */
+    minimap?: IEditorMinimapOptions;
+    /**
+     * Control the behavior of the find widget.
+     */
+    find?: IEditorFindOptions;
+    /**
+     * Display overflow widgets as `fixed`.
+     * Defaults to `false`.
+     */
+    fixedOverflowWidgets?: boolean;
+    /**
+     * The number of vertical lanes the overview ruler should render.
+     * Defaults to 3.
+     */
+    overviewRulerLanes?: number;
+    /**
+     * Controls if a border should be drawn around the overview ruler.
+     * Defaults to `true`.
+     */
+    overviewRulerBorder?: boolean;
+    /**
+     * Control the cursor animation style, possible values are 'blink', 'smooth', 'phase', 'expand' and 'solid'.
+     * Defaults to 'blink'.
+     */
+    cursorBlinking?: 'blink' | 'smooth' | 'phase' | 'expand' | 'solid';
+    /**
+     * Zoom the font in the editor when using the mouse wheel in combination with holding Ctrl.
+     * Defaults to false.
+     */
+    mouseWheelZoom?: boolean;
+    /**
+     * Control the mouse pointer style, either 'text' or 'default' or 'copy'
+     * Defaults to 'text'
+     */
+    mouseStyle?: 'text' | 'default' | 'copy';
+    /**
+     * Enable smooth caret animation.
+     * Defaults to 'off'.
+     */
+    cursorSmoothCaretAnimation?: 'off' | 'explicit' | 'on';
+    /**
+     * Control the cursor style, either 'block' or 'line'.
+     * Defaults to 'line'.
+     */
+    cursorStyle?: 'line' | 'block' | 'underline' | 'line-thin' | 'block-outline' | 'underline-thin';
+    /**
+     * Control the width of the cursor when cursorStyle is set to 'line'
+     */
+    cursorWidth?: number;
+    /**
+     * Enable font ligatures.
+     * Defaults to false.
+     */
+    fontLigatures?: boolean | string;
+    /**
+     * Enable font variations.
+     * Defaults to false.
+     */
+    fontVariations?: boolean | string;
+    /**
+     * Controls whether to use default color decorations or not using the default document color provider
+     */
+    defaultColorDecorators?: boolean;
+    /**
+     * Disable the use of `transform: translate3d(0px, 0px, 0px)` for the editor margin and lines layers.
+     * The usage of `transform: translate3d(0px, 0px, 0px)` acts as a hint for browsers to create an extra layer.
+     * Defaults to false.
+     */
+    disableLayerHinting?: boolean;
+    /**
+     * Disable the optimizations for monospace fonts.
+     * Defaults to false.
+     */
+    disableMonospaceOptimizations?: boolean;
+    /**
+     * Should the cursor be hidden in the overview ruler.
+     * Defaults to false.
+     */
+    hideCursorInOverviewRuler?: boolean;
+    /**
+     * Enable that scrolling can go one screen size after the last line.
+     * Defaults to true.
+     */
+    scrollBeyondLastLine?: boolean;
+    /**
+     * Enable that scrolling can go beyond the last column by a number of columns.
+     * Defaults to 5.
+     */
+    scrollBeyondLastColumn?: number;
+    /**
+     * Enable that the editor animates scrolling to a position.
+     * Defaults to false.
+     */
+    smoothScrolling?: boolean;
+    /**
+     * Enable that the editor will install a ResizeObserver to check if its container dom node size has changed.
+     * Defaults to false.
+     */
+    automaticLayout?: boolean;
+    /**
+     * Control the wrapping of the editor.
+     * When `wordWrap` = "off", the lines will never wrap.
+     * When `wordWrap` = "on", the lines will wrap at the viewport width.
+     * When `wordWrap` = "wordWrapColumn", the lines will wrap at `wordWrapColumn`.
+     * When `wordWrap` = "bounded", the lines will wrap at min(viewport width, wordWrapColumn).
+     * Defaults to "off".
+     */
+    wordWrap?: 'off' | 'on' | 'wordWrapColumn' | 'bounded';
+    /**
+     * Override the `wordWrap` setting.
+     */
+    wordWrapOverride1?: 'off' | 'on' | 'inherit';
+    /**
+     * Override the `wordWrapOverride1` setting.
+     */
+    wordWrapOverride2?: 'off' | 'on' | 'inherit';
+    /**
+     * Control the wrapping of the editor.
+     * When `wordWrap` = "off", the lines will never wrap.
+     * When `wordWrap` = "on", the lines will wrap at the viewport width.
+     * When `wordWrap` = "wordWrapColumn", the lines will wrap at `wordWrapColumn`.
+     * When `wordWrap` = "bounded", the lines will wrap at min(viewport width, wordWrapColumn).
+     * Defaults to 80.
+     */
+    wordWrapColumn?: number;
+    /**
+     * Control indentation of wrapped lines. Can be: 'none', 'same', 'indent' or 'deepIndent'.
+     * Defaults to 'same' in vscode and to 'none' in monaco-editor.
+     */
+    wrappingIndent?: 'none' | 'same' | 'indent' | 'deepIndent';
+    /**
+     * Controls the wrapping strategy to use.
+     * Defaults to 'simple'.
+     */
+    wrappingStrategy?: 'simple' | 'advanced';
+    /**
+     * Configure word wrapping characters. A break will be introduced before these characters.
+     */
+    wordWrapBreakBeforeCharacters?: string;
+    /**
+     * Configure word wrapping characters. A break will be introduced after these characters.
+     */
+    wordWrapBreakAfterCharacters?: string;
+    /**
+     * Sets whether line breaks appear wherever the text would otherwise overflow its content box.
+     * When wordBreak = 'normal', Use the default line break rule.
+     * When wordBreak = 'keepAll', Word breaks should not be used for Chinese/Japanese/Korean (CJK) text. Non-CJK text behavior is the same as for normal.
+     */
+    wordBreak?: 'normal' | 'keepAll';
+    /**
+     * Performance guard: Stop rendering a line after x characters.
+     * Defaults to 10000.
+     * Use -1 to never stop rendering
+     */
+    stopRenderingLineAfter?: number;
+    /**
+     * Configure the editor's hover.
+     */
+    hover?: IEditorHoverOptions;
+    /**
+     * Enable detecting links and making them clickable.
+     * Defaults to true.
+     */
+    links?: boolean;
+    /**
+     * Enable inline color decorators and color picker rendering.
+     */
+    colorDecorators?: boolean;
+    /**
+     * Controls the max number of color decorators that can be rendered in an editor at once.
+     */
+    colorDecoratorsLimit?: number;
+    /**
+     * Control the behaviour of comments in the editor.
+     */
+    comments?: IEditorCommentsOptions;
+    /**
+     * Enable custom contextmenu.
+     * Defaults to true.
+     */
+    contextmenu?: boolean;
+    /**
+     * A multiplier to be used on the `deltaX` and `deltaY` of mouse wheel scroll events.
+     * Defaults to 1.
+     */
+    mouseWheelScrollSensitivity?: number;
+    /**
+     * FastScrolling mulitplier speed when pressing `Alt`
+     * Defaults to 5.
+     */
+    fastScrollSensitivity?: number;
+    /**
+     * Enable that the editor scrolls only the predominant axis. Prevents horizontal drift when scrolling vertically on a trackpad.
+     * Defaults to true.
+     */
+    scrollPredominantAxis?: boolean;
+    /**
+     * Enable that the selection with the mouse and keys is doing column selection.
+     * Defaults to false.
+     */
+    columnSelection?: boolean;
+    /**
+     * The modifier to be used to add multiple cursors with the mouse.
+     * Defaults to 'alt'
+     */
+    multiCursorModifier?: 'ctrlCmd' | 'alt';
+    /**
+     * Merge overlapping selections.
+     * Defaults to true
+     */
+    multiCursorMergeOverlapping?: boolean;
+    /**
+     * Configure the behaviour when pasting a text with the line count equal to the cursor count.
+     * Defaults to 'spread'.
+     */
+    multiCursorPaste?: 'spread' | 'full';
+    /**
+     * Controls the max number of text cursors that can be in an active editor at once.
+     */
+    multiCursorLimit?: number;
+    /**
+     * Configure the editor's accessibility support.
+     * Defaults to 'auto'. It is best to leave this to 'auto'.
+     */
+    accessibilitySupport?: 'auto' | 'off' | 'on';
+    /**
+     * Controls the number of lines in the editor that can be read out by a screen reader
+     */
+    accessibilityPageSize?: number;
+    /**
+     * Suggest options.
+     */
+    suggest?: ISuggestOptions;
+    inlineSuggest?: IInlineSuggestOptions;
+    /**
+     * Smart select options.
+     */
+    smartSelect?: ISmartSelectOptions;
+    /**
+     *
+     */
+    gotoLocation?: IGotoLocationOptions;
+    /**
+     * Enable quick suggestions (shadow suggestions)
+     * Defaults to true.
+     */
+    quickSuggestions?: boolean | IQuickSuggestionsOptions;
+    /**
+     * Quick suggestions show delay (in ms)
+     * Defaults to 10 (ms)
+     */
+    quickSuggestionsDelay?: number;
+    /**
+     * Controls the spacing around the editor.
+     */
+    padding?: IEditorPaddingOptions;
+    /**
+     * Parameter hint options.
+     */
+    parameterHints?: IEditorParameterHintOptions;
+    /**
+     * Options for auto closing brackets.
+     * Defaults to language defined behavior.
+     */
+    autoClosingBrackets?: EditorAutoClosingStrategy;
+    /**
+     * Options for auto closing quotes.
+     * Defaults to language defined behavior.
+     */
+    autoClosingQuotes?: EditorAutoClosingStrategy;
+    /**
+     * Options for pressing backspace near quotes or bracket pairs.
+     */
+    autoClosingDelete?: EditorAutoClosingEditStrategy;
+    /**
+     * Options for typing over closing quotes or brackets.
+     */
+    autoClosingOvertype?: EditorAutoClosingEditStrategy;
+    /**
+     * Options for auto surrounding.
+     * Defaults to always allowing auto surrounding.
+     */
+    autoSurround?: EditorAutoSurroundStrategy;
+    /**
+     * Controls whether the editor should automatically adjust the indentation when users type, paste, move or indent lines.
+     * Defaults to advanced.
+     */
+    autoIndent?: 'none' | 'keep' | 'brackets' | 'advanced' | 'full';
+    /**
+     * Emulate selection behaviour of tab characters when using spaces for indentation.
+     * This means selection will stick to tab stops.
+     */
+    stickyTabStops?: boolean;
+    /**
+     * Enable format on type.
+     * Defaults to false.
+     */
+    formatOnType?: boolean;
+    /**
+     * Enable format on paste.
+     * Defaults to false.
+     */
+    formatOnPaste?: boolean;
+    /**
+     * Controls if the editor should allow to move selections via drag and drop.
+     * Defaults to false.
+     */
+    dragAndDrop?: boolean;
+    /**
+     * Enable the suggestion box to pop-up on trigger characters.
+     * Defaults to true.
+     */
+    suggestOnTriggerCharacters?: boolean;
+    /**
+     * Accept suggestions on ENTER.
+     * Defaults to 'on'.
+     */
+    acceptSuggestionOnEnter?: 'on' | 'smart' | 'off';
+    /**
+     * Accept suggestions on provider defined characters.
+     * Defaults to true.
+     */
+    acceptSuggestionOnCommitCharacter?: boolean;
+    /**
+     * Enable snippet suggestions. Default to 'true'.
+     */
+    snippetSuggestions?: 'top' | 'bottom' | 'inline' | 'none';
+    /**
+     * Copying without a selection copies the current line.
+     */
+    emptySelectionClipboard?: boolean;
+    /**
+     * Syntax highlighting is copied.
+     */
+    copyWithSyntaxHighlighting?: boolean;
+    /**
+     * The history mode for suggestions.
+     */
+    suggestSelection?: 'first' | 'recentlyUsed' | 'recentlyUsedByPrefix';
+    /**
+     * The font size for the suggest widget.
+     * Defaults to the editor font size.
+     */
+    suggestFontSize?: number;
+    /**
+     * The line height for the suggest widget.
+     * Defaults to the editor line height.
+     */
+    suggestLineHeight?: number;
+    /**
+     * Enable tab completion.
+     */
+    tabCompletion?: 'on' | 'off' | 'onlySnippets';
+    /**
+     * Enable selection highlight.
+     * Defaults to true.
+     */
+    selectionHighlight?: boolean;
+    /**
+     * Enable semantic occurrences highlight.
+     * Defaults to true.
+     */
+    occurrencesHighlight?: boolean;
+    /**
+     * Show code lens
+     * Defaults to true.
+     */
+    codeLens?: boolean;
+    /**
+     * Code lens font family. Defaults to editor font family.
+     */
+    codeLensFontFamily?: string;
+    /**
+     * Code lens font size. Default to 90% of the editor font size
+     */
+    codeLensFontSize?: number;
+    /**
+     * Control the behavior and rendering of the code action lightbulb.
+     */
+    lightbulb?: IEditorLightbulbOptions;
+    /**
+     * Timeout for running code actions on save.
+     */
+    codeActionsOnSaveTimeout?: number;
+    /**
+     * Enable code folding.
+     * Defaults to true.
+     */
+    folding?: boolean;
+    /**
+     * Selects the folding strategy. 'auto' uses the strategies contributed for the current document, 'indentation' uses the indentation based folding strategy.
+     * Defaults to 'auto'.
+     */
+    foldingStrategy?: 'auto' | 'indentation';
+    /**
+     * Enable highlight for folded regions.
+     * Defaults to true.
+     */
+    foldingHighlight?: boolean;
+    /**
+     * Auto fold imports folding regions.
+     * Defaults to true.
+     */
+    foldingImportsByDefault?: boolean;
+    /**
+     * Maximum number of foldable regions.
+     * Defaults to 5000.
+     */
+    foldingMaximumRegions?: number;
+    /**
+     * Controls whether the fold actions in the gutter stay always visible or hide unless the mouse is over the gutter.
+     * Defaults to 'mouseover'.
+     */
+    showFoldingControls?: 'always' | 'never' | 'mouseover';
+    /**
+     * Controls whether clicking on the empty content after a folded line will unfold the line.
+     * Defaults to false.
+     */
+    unfoldOnClickAfterEndOfLine?: boolean;
+    /**
+     * Enable highlighting of matching brackets.
+     * Defaults to 'always'.
+     */
+    matchBrackets?: 'never' | 'near' | 'always';
+    /**
+     * Enable experimental whitespace rendering.
+     * Defaults to 'svg'.
+     */
+    experimentalWhitespaceRendering?: 'svg' | 'font' | 'off';
+    /**
+     * Enable rendering of whitespace.
+     * Defaults to 'selection'.
+     */
+    renderWhitespace?: 'none' | 'boundary' | 'selection' | 'trailing' | 'all';
+    /**
+     * Enable rendering of control characters.
+     * Defaults to true.
+     */
+    renderControlCharacters?: boolean;
+    /**
+     * Enable rendering of current line highlight.
+     * Defaults to all.
+     */
+    renderLineHighlight?: 'none' | 'gutter' | 'line' | 'all';
+    /**
+     * Control if the current line highlight should be rendered only the editor is focused.
+     * Defaults to false.
+     */
+    renderLineHighlightOnlyWhenFocus?: boolean;
+    /**
+     * Inserting and deleting whitespace follows tab stops.
+     */
+    useTabStops?: boolean;
+    /**
+     * The font family
+     */
+    fontFamily?: string;
+    /**
+     * The font weight
+     */
+    fontWeight?: string;
+    /**
+     * The font size
+     */
+    fontSize?: number;
+    /**
+     * The line height
+     */
+    lineHeight?: number;
+    /**
+     * The letter spacing
+     */
+    letterSpacing?: number;
+    /**
+     * Controls fading out of unused variables.
+     */
+    showUnused?: boolean;
+    /**
+     * Controls whether to focus the inline editor in the peek widget by default.
+     * Defaults to false.
+     */
+    peekWidgetDefaultFocus?: 'tree' | 'editor';
+    /**
+     * Controls whether the definition link opens element in the peek widget.
+     * Defaults to false.
+     */
+    definitionLinkOpensInPeek?: boolean;
+    /**
+     * Controls strikethrough deprecated variables.
+     */
+    showDeprecated?: boolean;
+    /**
+     * Controls whether suggestions allow matches in the middle of the word instead of only at the beginning
+     */
+    matchOnWordStartOnly?: boolean;
+    /**
+     * Control the behavior and rendering of the inline hints.
+     */
+    inlayHints?: IEditorInlayHintsOptions;
+    /**
+     * Control if the editor should use shadow DOM.
+     */
+    useShadowDOM?: boolean;
+    /**
+     * Controls the behavior of editor guides.
+    */
+    guides?: IGuidesOptions;
+    /**
+     * Controls the behavior of the unicode highlight feature
+     * (by default, ambiguous and invisible characters are highlighted).
+     */
+    unicodeHighlight?: IUnicodeHighlightOptions;
+    /**
+     * Configures bracket pair colorization (disabled by default).
+    */
+    bracketPairColorization?: IBracketPairColorizationOptions;
+    /**
+     * Controls dropping into the editor from an external source.
+     *
+     * When enabled, this shows a preview of the drop location and triggers an `onDropIntoEditor` event.
+     */
+    dropIntoEditor?: IDropIntoEditorOptions;
+    /**
+     * Controls whether the editor receives tabs or defers them to the workbench for navigation.
+     */
+    tabFocusMode?: boolean;
+}
+interface IDiffEditorBaseOptions {
+    /**
+     * Allow the user to resize the diff editor split view.
+     * Defaults to true.
+     */
+    enableSplitViewResizing?: boolean;
+    /**
+     * The default ratio when rendering side-by-side editors.
+     * Must be a number between 0 and 1, min sizes apply.
+     * Defaults to 0.5
+     */
+    splitViewDefaultRatio?: number;
+    /**
+     * Render the differences in two side-by-side editors.
+     * Defaults to true.
+     */
+    renderSideBySide?: boolean;
+    /**
+     * Timeout in milliseconds after which diff computation is cancelled.
+     * Defaults to 5000.
+     */
+    maxComputationTime?: number;
+    /**
+     * Maximum supported file size in MB.
+     * Defaults to 50.
+     */
+    maxFileSize?: number;
+    /**
+     * Compute the diff by ignoring leading/trailing whitespace
+     * Defaults to true.
+     */
+    ignoreTrimWhitespace?: boolean;
+    /**
+     * Render +/- indicators for added/deleted changes.
+     * Defaults to true.
+     */
+    renderIndicators?: boolean;
+    /**
+     * Shows icons in the glyph margin to revert changes.
+     * Default to true.
+     */
+    renderMarginRevertIcon?: boolean;
+    /**
+     * Original model should be editable?
+     * Defaults to false.
+     */
+    originalEditable?: boolean;
+    /**
+     * Should the diff editor enable code lens?
+     * Defaults to false.
+     */
+    diffCodeLens?: boolean;
+    /**
+     * Is the diff editor should render overview ruler
+     * Defaults to true
+     */
+    renderOverviewRuler?: boolean;
+    /**
+     * Control the wrapping of the diff editor.
+     */
+    diffWordWrap?: 'off' | 'on' | 'inherit';
+    /**
+     * Diff Algorithm
+    */
+    diffAlgorithm?: 'legacy' | 'advanced' | IDocumentDiffProvider;
+    /**
+     * Whether the diff editor aria label should be verbose.
+     */
+    accessibilityVerbose?: boolean;
+}
+/**
+ * Configuration options for the diff editor.
+ */
+interface IDiffEditorOptions extends IEditorOptions, IDiffEditorBaseOptions {
+}
+/**
+ * Configuration options for editor comments
+ */
+interface IEditorCommentsOptions {
+    /**
+     * Insert a space after the line comment token and inside the block comments tokens.
+     * Defaults to true.
+     */
+    insertSpace?: boolean;
+    /**
+     * Ignore empty lines when inserting line comments.
+     * Defaults to true.
+     */
+    ignoreEmptyLines?: boolean;
+}
+/**
+ * Configuration options for editor find widget
+ */
+interface IEditorFindOptions {
+    /**
+    * Controls whether the cursor should move to find matches while typing.
+    */
+    cursorMoveOnType?: boolean;
+    /**
+     * Controls if we seed search string in the Find Widget with editor selection.
+     */
+    seedSearchStringFromSelection?: 'never' | 'always' | 'selection';
+    /**
+     * Controls if Find in Selection flag is turned on in the editor.
+     */
+    autoFindInSelection?: 'never' | 'always' | 'multiline';
+    addExtraSpaceOnTop?: boolean;
+    /**
+     * @internal
+     * Controls if the Find Widget should read or modify the shared find clipboard on macOS
+     */
+    globalFindClipboard?: boolean;
+    /**
+     * Controls whether the search result and diff result automatically restarts from the beginning (or the end) when no further matches can be found
+     */
+    loop?: boolean;
+}
+type GoToLocationValues = 'peek' | 'gotoAndPeek' | 'goto';
+/**
+ * Configuration options for go to location
+ */
+interface IGotoLocationOptions {
+    multiple?: GoToLocationValues;
+    multipleDefinitions?: GoToLocationValues;
+    multipleTypeDefinitions?: GoToLocationValues;
+    multipleDeclarations?: GoToLocationValues;
+    multipleImplementations?: GoToLocationValues;
+    multipleReferences?: GoToLocationValues;
+    alternativeDefinitionCommand?: string;
+    alternativeTypeDefinitionCommand?: string;
+    alternativeDeclarationCommand?: string;
+    alternativeImplementationCommand?: string;
+    alternativeReferenceCommand?: string;
+}
+/**
+ * Configuration options for editor hover
+ */
+interface IEditorHoverOptions {
+    /**
+     * Enable the hover.
+     * Defaults to true.
+     */
+    enabled?: boolean;
+    /**
+     * Delay for showing the hover.
+     * Defaults to 300.
+     */
+    delay?: number;
+    /**
+     * Is the hover sticky such that it can be clicked and its contents selected?
+     * Defaults to true.
+     */
+    sticky?: boolean;
+    /**
+     * Should the hover be shown above the line if possible?
+     * Defaults to false.
+     */
+    above?: boolean;
+}
+/**
+ * Configuration options for editor lightbulb
+ */
+interface IEditorLightbulbOptions {
+    /**
+     * Enable the lightbulb code action.
+     * Defaults to true.
+     */
+    enabled?: boolean;
+}
+interface IEditorStickyScrollOptions {
+    /**
+     * Enable the sticky scroll
+     */
+    enabled?: boolean;
+    /**
+     * Maximum number of sticky lines to show
+     */
+    maxLineCount?: number;
+    /**
+     * Model to choose for sticky scroll by default
+     */
+    defaultModel?: 'outlineModel' | 'foldingProviderModel' | 'indentationModel';
+}
+/**
+ * Configuration options for editor inlayHints
+ */
+interface IEditorInlayHintsOptions {
+    /**
+     * Enable the inline hints.
+     * Defaults to true.
+     */
+    enabled?: 'on' | 'off' | 'offUnlessPressed' | 'onUnlessPressed';
+    /**
+     * Font size of inline hints.
+     * Default to 90% of the editor font size.
+     */
+    fontSize?: number;
+    /**
+     * Font family of inline hints.
+     * Defaults to editor font family.
+     */
+    fontFamily?: string;
+    /**
+     * Enables the padding around the inlay hint.
+     * Defaults to false.
+     */
+    padding?: boolean;
+}
+/**
+ * Configuration options for editor minimap
+ */
+interface IEditorMinimapOptions {
+    /**
+     * Enable the rendering of the minimap.
+     * Defaults to true.
+     */
+    enabled?: boolean;
+    /**
+     * Control the rendering of minimap.
+     */
+    autohide?: boolean;
+    /**
+     * Control the side of the minimap in editor.
+     * Defaults to 'right'.
+     */
+    side?: 'right' | 'left';
+    /**
+     * Control the minimap rendering mode.
+     * Defaults to 'actual'.
+     */
+    size?: 'proportional' | 'fill' | 'fit';
+    /**
+     * Control the rendering of the minimap slider.
+     * Defaults to 'mouseover'.
+     */
+    showSlider?: 'always' | 'mouseover';
+    /**
+     * Render the actual text on a line (as opposed to color blocks).
+     * Defaults to true.
+     */
+    renderCharacters?: boolean;
+    /**
+     * Limit the width of the minimap to render at most a certain number of columns.
+     * Defaults to 120.
+     */
+    maxColumn?: number;
+    /**
+     * Relative size of the font in the minimap. Defaults to 1.
+     */
+    scale?: number;
+}
+/**
+ * Configuration options for editor padding
+ */
+interface IEditorPaddingOptions {
+    /**
+     * Spacing between top edge of editor and first line.
+     */
+    top?: number;
+    /**
+     * Spacing between bottom edge of editor and last line.
+     */
+    bottom?: number;
+}
+/**
+ * Configuration options for parameter hints
+ */
+interface IEditorParameterHintOptions {
+    /**
+     * Enable parameter hints.
+     * Defaults to true.
+     */
+    enabled?: boolean;
+    /**
+     * Enable cycling of parameter hints.
+     * Defaults to false.
+     */
+    cycle?: boolean;
+}
+type QuickSuggestionsValue = 'on' | 'inline' | 'off';
+/**
+ * Configuration options for quick suggestions
+ */
+interface IQuickSuggestionsOptions {
+    other?: boolean | QuickSuggestionsValue;
+    comments?: boolean | QuickSuggestionsValue;
+    strings?: boolean | QuickSuggestionsValue;
+}
+type LineNumbersType = 'on' | 'off' | 'relative' | 'interval' | ((lineNumber: number) => string);
+interface IRulerOption {
+    readonly column: number;
+    readonly color: string | null;
+}
+/**
+ * Configuration options for editor scrollbars
+ */
+interface IEditorScrollbarOptions {
+    /**
+     * The size of arrows (if displayed).
+     * Defaults to 11.
+     * **NOTE**: This option cannot be updated using `updateOptions()`
+     */
+    arrowSize?: number;
+    /**
+     * Render vertical scrollbar.
+     * Defaults to 'auto'.
+     */
+    vertical?: 'auto' | 'visible' | 'hidden';
+    /**
+     * Render horizontal scrollbar.
+     * Defaults to 'auto'.
+     */
+    horizontal?: 'auto' | 'visible' | 'hidden';
+    /**
+     * Cast horizontal and vertical shadows when the content is scrolled.
+     * Defaults to true.
+     * **NOTE**: This option cannot be updated using `updateOptions()`
+     */
+    useShadows?: boolean;
+    /**
+     * Render arrows at the top and bottom of the vertical scrollbar.
+     * Defaults to false.
+     * **NOTE**: This option cannot be updated using `updateOptions()`
+     */
+    verticalHasArrows?: boolean;
+    /**
+     * Render arrows at the left and right of the horizontal scrollbar.
+     * Defaults to false.
+     * **NOTE**: This option cannot be updated using `updateOptions()`
+     */
+    horizontalHasArrows?: boolean;
+    /**
+     * Listen to mouse wheel events and react to them by scrolling.
+     * Defaults to true.
+     */
+    handleMouseWheel?: boolean;
+    /**
+     * Always consume mouse wheel events (always call preventDefault() and stopPropagation() on the browser events).
+     * Defaults to true.
+     * **NOTE**: This option cannot be updated using `updateOptions()`
+     */
+    alwaysConsumeMouseWheel?: boolean;
+    /**
+     * Height in pixels for the horizontal scrollbar.
+     * Defaults to 10 (px).
+     */
+    horizontalScrollbarSize?: number;
+    /**
+     * Width in pixels for the vertical scrollbar.
+     * Defaults to 10 (px).
+     */
+    verticalScrollbarSize?: number;
+    /**
+     * Width in pixels for the vertical slider.
+     * Defaults to `verticalScrollbarSize`.
+     * **NOTE**: This option cannot be updated using `updateOptions()`
+     */
+    verticalSliderSize?: number;
+    /**
+     * Height in pixels for the horizontal slider.
+     * Defaults to `horizontalScrollbarSize`.
+     * **NOTE**: This option cannot be updated using `updateOptions()`
+     */
+    horizontalSliderSize?: number;
+    /**
+     * Scroll gutter clicks move by page vs jump to position.
+     * Defaults to false.
+     */
+    scrollByPage?: boolean;
+}
+type InUntrustedWorkspace = 'inUntrustedWorkspace';
+/**
+ * Configuration options for unicode highlighting.
+ */
+interface IUnicodeHighlightOptions {
+    /**
+     * Controls whether all non-basic ASCII characters are highlighted. Only characters between U+0020 and U+007E, tab, line-feed and carriage-return are considered basic ASCII.
+     */
+    nonBasicASCII?: boolean | InUntrustedWorkspace;
+    /**
+     * Controls whether characters that just reserve space or have no width at all are highlighted.
+     */
+    invisibleCharacters?: boolean;
+    /**
+     * Controls whether characters are highlighted that can be confused with basic ASCII characters, except those that are common in the current user locale.
+     */
+    ambiguousCharacters?: boolean;
+    /**
+     * Controls whether characters in comments should also be subject to unicode highlighting.
+     */
+    includeComments?: boolean | InUntrustedWorkspace;
+    /**
+     * Controls whether characters in strings should also be subject to unicode highlighting.
+     */
+    includeStrings?: boolean | InUntrustedWorkspace;
+    /**
+     * Defines allowed characters that are not being highlighted.
+     */
+    allowedCharacters?: Record<string, true>;
+    /**
+     * Unicode characters that are common in allowed locales are not being highlighted.
+     */
+    allowedLocales?: Record<string | '_os' | '_vscode', true>;
+}
+interface IInlineSuggestOptions {
+    /**
+     * Enable or disable the rendering of automatic inline completions.
+    */
+    enabled?: boolean;
+    /**
+     * Configures the mode.
+     * Use `prefix` to only show ghost text if the text to replace is a prefix of the suggestion text.
+     * Use `subword` to only show ghost text if the replace text is a subword of the suggestion text.
+     * Use `subwordSmart` to only show ghost text if the replace text is a subword of the suggestion text, but the subword must start after the cursor position.
+     * Defaults to `prefix`.
+    */
+    mode?: 'prefix' | 'subword' | 'subwordSmart';
+    showToolbar?: 'always' | 'onHover';
+    suppressSuggestions?: boolean;
+    /**
+     * Does not clear active inline suggestions when the editor loses focus.
+     */
+    keepOnBlur?: boolean;
+}
+interface IBracketPairColorizationOptions {
+    /**
+     * Enable or disable bracket pair colorization.
+    */
+    enabled?: boolean;
+    /**
+     * Use independent color pool per bracket type.
+    */
+    independentColorPoolPerBracketType?: boolean;
+}
+interface IGuidesOptions {
+    /**
+     * Enable rendering of bracket pair guides.
+     * Defaults to false.
+    */
+    bracketPairs?: boolean | 'active';
+    /**
+     * Enable rendering of vertical bracket pair guides.
+     * Defaults to 'active'.
+     */
+    bracketPairsHorizontal?: boolean | 'active';
+    /**
+     * Enable highlighting of the active bracket pair.
+     * Defaults to true.
+    */
+    highlightActiveBracketPair?: boolean;
+    /**
+     * Enable rendering of indent guides.
+     * Defaults to true.
+     */
+    indentation?: boolean;
+    /**
+     * Enable highlighting of the active indent guide.
+     * Defaults to true.
+     */
+    highlightActiveIndentation?: boolean | 'always';
+}
+/**
+ * Configuration options for editor suggest widget
+ */
+interface ISuggestOptions {
+    /**
+     * Overwrite word ends on accept. Default to false.
+     */
+    insertMode?: 'insert' | 'replace';
+    /**
+     * Enable graceful matching. Defaults to true.
+     */
+    filterGraceful?: boolean;
+    /**
+     * Prevent quick suggestions when a snippet is active. Defaults to true.
+     */
+    snippetsPreventQuickSuggestions?: boolean;
+    /**
+     * Favors words that appear close to the cursor.
+     */
+    localityBonus?: boolean;
+    /**
+     * Enable using global storage for remembering suggestions.
+     */
+    shareSuggestSelections?: boolean;
+    /**
+     * Select suggestions when triggered via quick suggest or trigger characters
+     */
+    selectionMode?: 'always' | 'never' | 'whenTriggerCharacter' | 'whenQuickSuggestion';
+    /**
+     * Enable or disable icons in suggestions. Defaults to true.
+     */
+    showIcons?: boolean;
+    /**
+     * Enable or disable the suggest status bar.
+     */
+    showStatusBar?: boolean;
+    /**
+     * Enable or disable the rendering of the suggestion preview.
+     */
+    preview?: boolean;
+    /**
+     * Configures the mode of the preview.
+    */
+    previewMode?: 'prefix' | 'subword' | 'subwordSmart';
+    /**
+     * Show details inline with the label. Defaults to true.
+     */
+    showInlineDetails?: boolean;
+    /**
+     * Show method-suggestions.
+     */
+    showMethods?: boolean;
+    /**
+     * Show function-suggestions.
+     */
+    showFunctions?: boolean;
+    /**
+     * Show constructor-suggestions.
+     */
+    showConstructors?: boolean;
+    /**
+     * Show deprecated-suggestions.
+     */
+    showDeprecated?: boolean;
+    /**
+     * Controls whether suggestions allow matches in the middle of the word instead of only at the beginning
+     */
+    matchOnWordStartOnly?: boolean;
+    /**
+     * Show field-suggestions.
+     */
+    showFields?: boolean;
+    /**
+     * Show variable-suggestions.
+     */
+    showVariables?: boolean;
+    /**
+     * Show class-suggestions.
+     */
+    showClasses?: boolean;
+    /**
+     * Show struct-suggestions.
+     */
+    showStructs?: boolean;
+    /**
+     * Show interface-suggestions.
+     */
+    showInterfaces?: boolean;
+    /**
+     * Show module-suggestions.
+     */
+    showModules?: boolean;
+    /**
+     * Show property-suggestions.
+     */
+    showProperties?: boolean;
+    /**
+     * Show event-suggestions.
+     */
+    showEvents?: boolean;
+    /**
+     * Show operator-suggestions.
+     */
+    showOperators?: boolean;
+    /**
+     * Show unit-suggestions.
+     */
+    showUnits?: boolean;
+    /**
+     * Show value-suggestions.
+     */
+    showValues?: boolean;
+    /**
+     * Show constant-suggestions.
+     */
+    showConstants?: boolean;
+    /**
+     * Show enum-suggestions.
+     */
+    showEnums?: boolean;
+    /**
+     * Show enumMember-suggestions.
+     */
+    showEnumMembers?: boolean;
+    /**
+     * Show keyword-suggestions.
+     */
+    showKeywords?: boolean;
+    /**
+     * Show text-suggestions.
+     */
+    showWords?: boolean;
+    /**
+     * Show color-suggestions.
+     */
+    showColors?: boolean;
+    /**
+     * Show file-suggestions.
+     */
+    showFiles?: boolean;
+    /**
+     * Show reference-suggestions.
+     */
+    showReferences?: boolean;
+    /**
+     * Show folder-suggestions.
+     */
+    showFolders?: boolean;
+    /**
+     * Show typeParameter-suggestions.
+     */
+    showTypeParameters?: boolean;
+    /**
+     * Show issue-suggestions.
+     */
+    showIssues?: boolean;
+    /**
+     * Show user-suggestions.
+     */
+    showUsers?: boolean;
+    /**
+     * Show snippet-suggestions.
+     */
+    showSnippets?: boolean;
+}
+interface ISmartSelectOptions {
+    selectLeadingAndTrailingWhitespace?: boolean;
+}
+/**
+ * Configuration options for editor drop into behavior
+ */
+interface IDropIntoEditorOptions {
+    /**
+     * Enable dropping into editor.
+     * Defaults to true.
+     */
+    enabled?: boolean;
+    /**
+     * Controls if a widget is shown after a drop.
+     * Defaults to 'afterDrop'.
+     */
+    showDropSelector?: 'afterDrop' | 'never';
+}
+
+interface IDiffComputationResult {
+    quitEarly: boolean;
+    identical: boolean;
+    /**
+     * The changes as (legacy) line change array.
+     */
+    changes: ILineChange[];
+    /**
+     * The changes as (modern) line range mapping array.
+     */
+    changes2: LineRangeMapping[];
+}
+/**
+ * A change
+ */
+interface IChange {
+    readonly originalStartLineNumber: number;
+    readonly originalEndLineNumber: number;
+    readonly modifiedStartLineNumber: number;
+    readonly modifiedEndLineNumber: number;
+}
+/**
+ * A character level change.
+ */
+interface ICharChange extends IChange {
+    readonly originalStartColumn: number;
+    readonly originalEndColumn: number;
+    readonly modifiedStartColumn: number;
+    readonly modifiedEndColumn: number;
+}
+/**
+ * A line change
+ */
+interface ILineChange extends IChange {
+    readonly charChanges: ICharChange[] | undefined;
+}
+
+interface IDimension {
+    width: number;
+    height: number;
+}
+
+/**
+ * A model for the diff editor.
+ */
+interface IDiffEditorModel {
+    /**
+     * Original model.
+     */
+    original: ITextModel;
+    /**
+     * Modified model.
+     */
+    modified: ITextModel;
+}
+interface IEditorAction {
+    readonly id: string;
+    readonly label: string;
+    readonly alias: string;
+    isSupported(): boolean;
+    run(args?: unknown): Promise<void>;
+}
+type IEditorModel = ITextModel | IDiffEditorModel;
+/**
+ * A (serializable) state of the cursors.
+ */
+interface ICursorState {
+    inSelectionMode: boolean;
+    selectionStart: IPosition;
+    position: IPosition;
+}
+/**
+ * A (serializable) state of the view.
+ */
+interface IViewState {
+    /** written by previous versions */
+    scrollTop?: number;
+    /** written by previous versions */
+    scrollTopWithoutViewZones?: number;
+    scrollLeft: number;
+    firstPosition: IPosition;
+    firstPositionDeltaTop: number;
+}
+/**
+ * A (serializable) state of the code editor.
+ */
+interface ICodeEditorViewState {
+    cursorState: ICursorState[];
+    viewState: IViewState;
+    contributionsState: {
+        [id: string]: any;
+    };
+}
+/**
+ * (Serializable) View state for the diff editor.
+ */
+interface IDiffEditorViewState {
+    original: ICodeEditorViewState | null;
+    modified: ICodeEditorViewState | null;
+}
+/**
+ * An editor view state.
+ */
+type IEditorViewState = ICodeEditorViewState | IDiffEditorViewState;
+declare const enum ScrollType {
+    Smooth = 0,
+    Immediate = 1
+}
+/**
+ * An editor.
+ */
+interface IEditor {
+    /**
+     * An event emitted when the editor has been disposed.
+     * @event
+     */
+    onDidDispose(listener: () => void): IDisposable;
+    /**
+     * Dispose the editor.
+     */
+    dispose(): void;
+    /**
+     * Get a unique id for this editor instance.
+     */
+    getId(): string;
+    /**
+     * Get the editor type. Please see `EditorType`.
+     * This is to avoid an instanceof check
+     */
+    getEditorType(): string;
+    /**
+     * Update the editor's options after the editor has been created.
+     */
+    updateOptions(newOptions: IEditorOptions): void;
+    /**
+     * Indicates that the editor becomes visible.
+     * @internal
+     */
+    onVisible(): void;
+    /**
+     * Indicates that the editor becomes hidden.
+     * @internal
+     */
+    onHide(): void;
+    /**
+     * Instructs the editor to remeasure its container. This method should
+     * be called when the container of the editor gets resized.
+     *
+     * If a dimension is passed in, the passed in value will be used.
+     */
+    layout(dimension?: IDimension): void;
+    /**
+     * Brings browser focus to the editor text
+     */
+    focus(): void;
+    /**
+     * Returns true if the text inside this editor is focused (i.e. cursor is blinking).
+     */
+    hasTextFocus(): boolean;
+    /**
+     * Returns all actions associated with this editor.
+     */
+    getSupportedActions(): IEditorAction[];
+    /**
+     * Saves current view state of the editor in a serializable object.
+     */
+    saveViewState(): IEditorViewState | null;
+    /**
+     * Restores the view state of the editor from a serializable object generated by `saveViewState`.
+     */
+    restoreViewState(state: IEditorViewState | null): void;
+    /**
+     * Given a position, returns a column number that takes tab-widths into account.
+     */
+    getVisibleColumnFromPosition(position: IPosition): number;
+    /**
+     * Given a position, returns a column number that takes tab-widths into account.
+     * @internal
+     */
+    getStatusbarColumn(position: IPosition): number;
+    /**
+     * Returns the primary position of the cursor.
+     */
+    getPosition(): Position | null;
+    /**
+     * Set the primary position of the cursor. This will remove any secondary cursors.
+     * @param position New primary cursor's position
+     * @param source Source of the call that caused the position
+     */
+    setPosition(position: IPosition, source?: string): void;
+    /**
+     * Scroll vertically as necessary and reveal a line.
+     */
+    revealLine(lineNumber: number, scrollType?: ScrollType): void;
+    /**
+     * Scroll vertically as necessary and reveal a line centered vertically.
+     */
+    revealLineInCenter(lineNumber: number, scrollType?: ScrollType): void;
+    /**
+     * Scroll vertically as necessary and reveal a line centered vertically only if it lies outside the viewport.
+     */
+    revealLineInCenterIfOutsideViewport(lineNumber: number, scrollType?: ScrollType): void;
+    /**
+     * Scroll vertically as necessary and reveal a line close to the top of the viewport,
+     * optimized for viewing a code definition.
+     */
+    revealLineNearTop(lineNumber: number, scrollType?: ScrollType): void;
+    /**
+     * Scroll vertically or horizontally as necessary and reveal a position.
+     */
+    revealPosition(position: IPosition, scrollType?: ScrollType): void;
+    /**
+     * Scroll vertically or horizontally as necessary and reveal a position centered vertically.
+     */
+    revealPositionInCenter(position: IPosition, scrollType?: ScrollType): void;
+    /**
+     * Scroll vertically or horizontally as necessary and reveal a position centered vertically only if it lies outside the viewport.
+     */
+    revealPositionInCenterIfOutsideViewport(position: IPosition, scrollType?: ScrollType): void;
+    /**
+     * Scroll vertically or horizontally as necessary and reveal a position close to the top of the viewport,
+     * optimized for viewing a code definition.
+     */
+    revealPositionNearTop(position: IPosition, scrollType?: ScrollType): void;
+    /**
+     * Returns the primary selection of the editor.
+     */
+    getSelection(): Selection | null;
+    /**
+     * Returns all the selections of the editor.
+     */
+    getSelections(): Selection[] | null;
+    /**
+     * Set the primary selection of the editor. This will remove any secondary cursors.
+     * @param selection The new selection
+     * @param source Source of the call that caused the selection
+     */
+    setSelection(selection: IRange, source?: string): void;
+    /**
+     * Set the primary selection of the editor. This will remove any secondary cursors.
+     * @param selection The new selection
+     * @param source Source of the call that caused the selection
+     */
+    setSelection(selection: Range, source?: string): void;
+    /**
+     * Set the primary selection of the editor. This will remove any secondary cursors.
+     * @param selection The new selection
+     * @param source Source of the call that caused the selection
+     */
+    setSelection(selection: ISelection, source?: string): void;
+    /**
+     * Set the primary selection of the editor. This will remove any secondary cursors.
+     * @param selection The new selection
+     * @param source Source of the call that caused the selection
+     */
+    setSelection(selection: Selection, source?: string): void;
+    /**
+     * Set the selections for all the cursors of the editor.
+     * Cursors will be removed or added, as necessary.
+     * @param selections The new selection
+     * @param source Source of the call that caused the selection
+     */
+    setSelections(selections: readonly ISelection[], source?: string): void;
+    /**
+     * Scroll vertically as necessary and reveal lines.
+     */
+    revealLines(startLineNumber: number, endLineNumber: number, scrollType?: ScrollType): void;
+    /**
+     * Scroll vertically as necessary and reveal lines centered vertically.
+     */
+    revealLinesInCenter(lineNumber: number, endLineNumber: number, scrollType?: ScrollType): void;
+    /**
+     * Scroll vertically as necessary and reveal lines centered vertically only if it lies outside the viewport.
+     */
+    revealLinesInCenterIfOutsideViewport(lineNumber: number, endLineNumber: number, scrollType?: ScrollType): void;
+    /**
+     * Scroll vertically as necessary and reveal lines close to the top of the viewport,
+     * optimized for viewing a code definition.
+     */
+    revealLinesNearTop(lineNumber: number, endLineNumber: number, scrollType?: ScrollType): void;
+    /**
+     * Scroll vertically or horizontally as necessary and reveal a range.
+     */
+    revealRange(range: IRange, scrollType?: ScrollType): void;
+    /**
+     * Scroll vertically or horizontally as necessary and reveal a range centered vertically.
+     */
+    revealRangeInCenter(range: IRange, scrollType?: ScrollType): void;
+    /**
+     * Scroll vertically or horizontally as necessary and reveal a range at the top of the viewport.
+     */
+    revealRangeAtTop(range: IRange, scrollType?: ScrollType): void;
+    /**
+     * Scroll vertically or horizontally as necessary and reveal a range centered vertically only if it lies outside the viewport.
+     */
+    revealRangeInCenterIfOutsideViewport(range: IRange, scrollType?: ScrollType): void;
+    /**
+     * Scroll vertically or horizontally as necessary and reveal a range close to the top of the viewport,
+     * optimized for viewing a code definition.
+     */
+    revealRangeNearTop(range: IRange, scrollType?: ScrollType): void;
+    /**
+     * Scroll vertically or horizontally as necessary and reveal a range close to the top of the viewport,
+     * optimized for viewing a code definition. Only if it lies outside the viewport.
+     */
+    revealRangeNearTopIfOutsideViewport(range: IRange, scrollType?: ScrollType): void;
+    /**
+     * Directly trigger a handler or an editor action.
+     * @param source The source of the call.
+     * @param handlerId The id of the handler or the id of a contribution.
+     * @param payload Extra data to be sent to the handler.
+     */
+    trigger(source: string | null | undefined, handlerId: string, payload: any): void;
+    /**
+     * Gets the current model attached to this editor.
+     */
+    getModel(): IEditorModel | null;
+    /**
+     * Sets the current model attached to this editor.
+     * If the previous model was created by the editor via the value key in the options
+     * literal object, it will be destroyed. Otherwise, if the previous model was set
+     * via setModel, or the model key in the options literal object, the previous model
+     * will not be destroyed.
+     * It is safe to call setModel(null) to simply detach the current model from the editor.
+     */
+    setModel(model: IEditorModel | null): void;
+    /**
+     * Create a collection of decorations. All decorations added through this collection
+     * will get the ownerId of the editor (meaning they will not show up in other editors).
+     * These decorations will be automatically cleared when the editor's model changes.
+     */
+    createDecorationsCollection(decorations?: IModelDeltaDecoration[]): IEditorDecorationsCollection;
+    /**
+     * Change the decorations. All decorations added through this changeAccessor
+     * will get the ownerId of the editor (meaning they will not show up in other
+     * editors).
+     * @see {@link ITextModel.changeDecorations}
+     * @internal
+     */
+    changeDecorations(callback: (changeAccessor: IModelDecorationsChangeAccessor) => any): any;
+}
+/**
+ * A diff editor.
+ *
+ * @internal
+ */
+interface IDiffEditor$1 extends IEditor {
+    /**
+     * Type the getModel() of IEditor.
+     */
+    getModel(): IDiffEditorModel | null;
+    /**
+     * Get the `original` editor.
+     */
+    getOriginalEditor(): IEditor;
+    /**
+     * Get the `modified` editor.
+     */
+    getModifiedEditor(): IEditor;
+}
+/**
+ * A collection of decorations
+ */
+interface IEditorDecorationsCollection {
+    /**
+     * An event emitted when decorations change in the editor,
+     * but the change is not caused by us setting or clearing the collection.
+     */
+    onDidChange: Event<IModelDecorationsChangedEvent>;
+    /**
+     * Get the decorations count.
+     */
+    length: number;
+    /**
+     * Get the range for a decoration.
+     */
+    getRange(index: number): Range | null;
+    /**
+     * Get all ranges for decorations.
+     */
+    getRanges(): Range[];
+    /**
+     * Determine if a decoration is in this collection.
+     */
+    has(decoration: IModelDecoration): boolean;
+    /**
+     * Replace all previous decorations with `newDecorations`.
+     */
+    set(newDecorations: readonly IModelDeltaDecoration[]): string[];
+    /**
+     * Remove all previous decorations.
+     */
+    clear(): void;
+}
+/**
+ * An editor contribution that gets created every time a new editor gets created and gets disposed when the editor gets disposed.
+ */
+interface IEditorContribution {
+    /**
+     * Dispose this contribution.
+     */
+    dispose(): void;
+    /**
+     * Store view state.
+     */
+    saveViewState?(): any;
+    /**
+     * Restore view state.
+     */
+    restoreViewState?(state: any): void;
+}
+/**
+ * @internal
+ */
+interface IThemeDecorationRenderOptions {
+    backgroundColor?: string | ThemeColor;
+    outline?: string;
+    outlineColor?: string | ThemeColor;
+    outlineStyle?: string;
+    outlineWidth?: string;
+    border?: string;
+    borderColor?: string | ThemeColor;
+    borderRadius?: string;
+    borderSpacing?: string;
+    borderStyle?: string;
+    borderWidth?: string;
+    fontStyle?: string;
+    fontWeight?: string;
+    fontSize?: string;
+    textDecoration?: string;
+    cursor?: string;
+    color?: string | ThemeColor;
+    opacity?: string;
+    letterSpacing?: string;
+    gutterIconPath?: UriComponents;
+    gutterIconSize?: string;
+    overviewRulerColor?: string | ThemeColor;
+    /**
+     * @deprecated
+     */
+    before?: IContentDecorationRenderOptions;
+    /**
+     * @deprecated
+     */
+    after?: IContentDecorationRenderOptions;
+    /**
+     * @deprecated
+     */
+    beforeInjectedText?: IContentDecorationRenderOptions & {
+        affectsLetterSpacing?: boolean;
+    };
+    /**
+     * @deprecated
+     */
+    afterInjectedText?: IContentDecorationRenderOptions & {
+        affectsLetterSpacing?: boolean;
+    };
+}
+/**
+ * @internal
+ */
+interface IContentDecorationRenderOptions {
+    contentText?: string;
+    contentIconPath?: UriComponents;
+    border?: string;
+    borderColor?: string | ThemeColor;
+    borderRadius?: string;
+    fontStyle?: string;
+    fontWeight?: string;
+    fontSize?: string;
+    fontFamily?: string;
+    textDecoration?: string;
+    color?: string | ThemeColor;
+    backgroundColor?: string | ThemeColor;
+    opacity?: string;
+    verticalAlign?: string;
+    margin?: string;
+    padding?: string;
+    width?: string;
+    height?: string;
+}
+/**
+ * @internal
+ */
+interface IDecorationRenderOptions extends IThemeDecorationRenderOptions {
+    isWholeLine?: boolean;
+    rangeBehavior?: TrackedRangeStickiness;
+    overviewRulerLane?: OverviewRulerLane;
+    light?: IThemeDecorationRenderOptions;
+    dark?: IThemeDecorationRenderOptions;
+}
+
+declare const ITextModelService: ServiceIdentifier<ITextModelService>;
+interface ITextModelService {
+    readonly _serviceBrand: undefined;
+    /**
+     * Provided a resource URI, it will return a model reference
+     * which should be disposed once not needed anymore.
+     */
+    createModelReference(resource: URI): Promise<IReference<IResolvedTextEditorModel>>;
+    /**
+     * Registers a specific `scheme` content provider.
+     */
+    registerTextModelContentProvider(scheme: string, provider: ITextModelContentProvider): IDisposable;
+    /**
+     * Check if the given resource can be resolved to a text model.
+     */
+    canHandleResource(resource: URI): boolean;
+}
+interface ITextModelContentProvider {
+    /**
+     * Given a resource, return the content of the resource as `ITextModel`.
+     */
+    provideTextContent(resource: URI): Promise<ITextModel | null> | null;
+}
+interface ITextEditorModel extends IEditorModel$1 {
+    /**
+     * 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;
+}
+
+/**
+ * A rich code editor.
+ */
+type ICodeEditor = monaco.editor.ICodeEditor
+/**
+ * Information about a line in the diff editor
+ */
+interface IDiffLineInformation {
+    readonly equivalentLineNumber: number;
+}
+/**
+ * A rich diff editor.
+ */
+interface IDiffEditor extends IEditor {
+    /**
+     * Returns whether the diff editor is ignoring trim whitespace or not.
+     * @internal
+     */
+    readonly ignoreTrimWhitespace: boolean;
+    /**
+     * Returns whether the diff editor is rendering side by side or inline.
+     * @internal
+     */
+    readonly renderSideBySide: boolean;
+    /**
+     * Timeout in milliseconds after which diff computation is cancelled.
+     * @internal
+     */
+    readonly maxComputationTime: number;
+    /**
+     * @see {@link ICodeEditor.getContainerDomNode}
+     */
+    getContainerDomNode(): HTMLElement;
+    /**
+     * An event emitted when the diff information computed by this diff editor has been updated.
+     * @event
+     */
+    readonly onDidUpdateDiff: Event<void>;
+    /**
+     * An event emitted when the diff model is changed (i.e. the diff editor shows new content).
+     * @event
+     */
+    readonly onDidChangeModel: Event<void>;
+    /**
+     * Saves current view state of the editor in a serializable object.
+     */
+    saveViewState(): IDiffEditorViewState | null;
+    /**
+     * Restores the view state of the editor from a serializable object generated by `saveViewState`.
+     */
+    restoreViewState(state: IDiffEditorViewState | null): void;
+    /**
+     * Type the getModel() of IEditor.
+     */
+    getModel(): IDiffEditorModel | null;
+    /**
+     * Sets the current model attached to this editor.
+     * If the previous model was created by the editor via the value key in the options
+     * literal object, it will be destroyed. Otherwise, if the previous model was set
+     * via setModel, or the model key in the options literal object, the previous model
+     * will not be destroyed.
+     * It is safe to call setModel(null) to simply detach the current model from the editor.
+     */
+    setModel(model: IDiffEditorModel | null): void;
+    /**
+     * Get the `original` editor.
+     */
+    getOriginalEditor(): ICodeEditor;
+    /**
+     * Get the `modified` editor.
+     */
+    getModifiedEditor(): ICodeEditor;
+    /**
+     * Get the computed diff information.
+     */
+    getLineChanges(): ILineChange[] | null;
+    /**
+     * Get the computed diff information.
+     * @internal
+     */
+    getDiffComputationResult(): IDiffComputationResult | null;
+    /**
+     * Get information based on computed diff about a line number from the original model.
+     * If the diff computation is not finished or the model is missing, will return null.
+     */
+    getDiffLineInformationForOriginal(lineNumber: number): IDiffLineInformation | null;
+    /**
+     * Get information based on computed diff about a line number from the modified model.
+     * If the diff computation is not finished or the model is missing, will return null.
+     */
+    getDiffLineInformationForModified(lineNumber: number): IDiffLineInformation | null;
+    /**
+     * Update the editor's options after the editor has been created.
+     */
+    updateOptions(newOptions: IDiffEditorOptions): void;
+}
+
+export { EndOfLineSequence as E, ITextBufferFactory as I, Position as P, Range as R, Selection as S, ITextModel as a, ITextModelCreationOptions as b, IEditor as c, IDiffEditor$1 as d, IRange as e, IPosition as f, IDocumentDiffProviderOptions as g, IDocumentDiff as h, IChange as i, ICodeEditor as j, IDiffEditor as k, IDecorationRenderOptions as l, IModelDecorationOptions as m, ITextModelContentProvider as n, ITextModelService as o, IResolvedTextEditorModel as p, IModelDecorationsChangeAccessor as q, IEditorContribution as r, ISingleEditOperation as s, EditorAutoIndentStrategy as t, IDimension as u, ITextEditorModel as v, ITextSnapshot as w };