@codingame/monaco-vscode-api 1.67.15 → 1.67.18

package/dist/monaco.d.ts

@@ -0,0 +1,2683 @@
+import * as monaco from 'monaco-editor';
+import * as vscode from 'vscode';
+
+interface IDisposable {
+    dispose(): void;
+}
+declare class DisposableStore implements IDisposable {
+    static DISABLE_DISPOSED_WARNING: boolean;
+    private _toDispose;
+    private _isDisposed;
+    constructor();
+    /**
+     * Dispose of all registered disposables and mark this object as disposed.
+     *
+     * Any future disposables added to this object will be disposed of on `add`.
+     */
+    dispose(): void;
+    /**
+     * Returns `true` if this object has been disposed
+     */
+    get isDisposed(): boolean;
+    /**
+     * Dispose of all registered disposables but do not mark this object as disposed.
+     */
+    clear(): void;
+    add<T extends IDisposable>(o: T): T;
+}
+
+interface UriComponents {
+    scheme: string;
+    authority: string;
+    path: string;
+    query: string;
+    fragment: string;
+}
+
+/**
+ * To an event a function with one or zero parameters
+ * can be subscribed. The event is the subscriber function itself.
+ */
+type Event<T> = vscode.Event<T>
+declare namespace Event {
+    const None: Event<any>;
+    /**
+     * Given an event, returns another event which only fires once.
+     */
+    function once<T>(event: Event<T>): Event<T>;
+    /**
+     * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
+     * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
+     * returned event causes this utility to leak a listener on the original event.
+     */
+    function map<I, O>(event: Event<I>, map: (i: I) => O, disposable?: DisposableStore): Event<O>;
+    /**
+     * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
+     * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
+     * returned event causes this utility to leak a listener on the original event.
+     */
+    function forEach<I>(event: Event<I>, each: (i: I) => void, disposable?: DisposableStore): Event<I>;
+    /**
+     * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
+     * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
+     * returned event causes this utility to leak a listener on the original event.
+     */
+    function filter<T, U>(event: Event<T | U>, filter: (e: T | U) => e is T, disposable?: DisposableStore): Event<T>;
+    function filter<T>(event: Event<T>, filter: (e: T) => boolean, disposable?: DisposableStore): Event<T>;
+    function filter<T, R>(event: Event<T | R>, filter: (e: T | R) => e is R, disposable?: DisposableStore): Event<R>;
+    /**
+     * Given an event, returns the same event but typed as `Event<void>`.
+     */
+    function signal<T>(event: Event<T>): Event<void>;
+    /**
+     * Given a collection of events, returns a single event which emits
+     * whenever any of the provided events emit.
+     */
+    function any<T>(...events: Event<T>[]): Event<T>;
+    function any(...events: Event<any>[]): Event<void>;
+    /**
+     * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
+     * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
+     * returned event causes this utility to leak a listener on the original event.
+     */
+    function reduce<I, O>(event: Event<I>, merge: (last: O | undefined, event: I) => O, initial?: O, disposable?: DisposableStore): Event<O>;
+    /**
+     * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
+     * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
+     * returned event causes this utility to leak a listener on the original event.
+     */
+    function debounce<T>(event: Event<T>, merge: (last: T | undefined, event: T) => T, delay?: number, leading?: boolean, leakWarningThreshold?: number, disposable?: DisposableStore): Event<T>;
+    /**
+     * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
+     * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
+     * returned event causes this utility to leak a listener on the original event.
+     */
+    function debounce<I, O>(event: Event<I>, merge: (last: O | undefined, event: I) => O, delay?: number, leading?: boolean, leakWarningThreshold?: number, disposable?: DisposableStore): Event<O>;
+    /**
+     * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
+     * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
+     * returned event causes this utility to leak a listener on the original event.
+     */
+    function latch<T>(event: Event<T>, equals?: (a: T, b: T) => boolean, disposable?: DisposableStore): Event<T>;
+    /**
+     * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
+     * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
+     * returned event causes this utility to leak a listener on the original event.
+     */
+    function split<T, U>(event: Event<T | U>, isT: (e: T | U) => e is T, disposable?: DisposableStore): [Event<T>, Event<U>];
+    /**
+     * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
+     * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
+     * returned event causes this utility to leak a listener on the original event.
+     */
+    function buffer<T>(event: Event<T>, flushAfterTimeout?: boolean, _buffer?: T[]): Event<T>;
+    interface IChainableEvent<T> {
+        event: Event<T>;
+        map<O>(fn: (i: T) => O): IChainableEvent<O>;
+        forEach(fn: (i: T) => void): IChainableEvent<T>;
+        filter(fn: (e: T) => boolean): IChainableEvent<T>;
+        filter<R>(fn: (e: T | R) => e is R): IChainableEvent<R>;
+        reduce<R>(merge: (last: R | undefined, event: T) => R, initial?: R): IChainableEvent<R>;
+        latch(): IChainableEvent<T>;
+        debounce(merge: (last: T | undefined, event: T) => T, delay?: number, leading?: boolean, leakWarningThreshold?: number): IChainableEvent<T>;
+        debounce<R>(merge: (last: R | undefined, event: T) => R, delay?: number, leading?: boolean, leakWarningThreshold?: number): IChainableEvent<R>;
+        on(listener: (e: T) => any, thisArgs?: any, disposables?: IDisposable[] | DisposableStore): IDisposable;
+        once(listener: (e: T) => any, thisArgs?: any, disposables?: IDisposable[]): IDisposable;
+    }
+    /**
+     * @deprecated DO NOT use, this leaks memory
+     */
+    function chain<T>(event: Event<T>): IChainableEvent<T>;
+    interface NodeEventEmitter {
+        on(event: string | symbol, listener: Function): unknown;
+        removeListener(event: string | symbol, listener: Function): unknown;
+    }
+    function fromNodeEventEmitter<T>(emitter: NodeEventEmitter, eventName: string, map?: (...args: any[]) => T): Event<T>;
+    interface DOMEventEmitter {
+        addEventListener(event: string | symbol, listener: Function): void;
+        removeEventListener(event: string | symbol, listener: Function): void;
+    }
+    function fromDOMEventEmitter<T>(emitter: DOMEventEmitter, eventName: string, map?: (...args: any[]) => T): Event<T>;
+    function toPromise<T>(event: Event<T>): Promise<T>;
+    function runAndSubscribe<T>(event: Event<T>, handler: (e: T | undefined) => any): IDisposable;
+    function runAndSubscribeWithStore<T>(event: Event<T>, handler: (e: T | undefined, disposableStore: DisposableStore) => any): IDisposable;
+}
+
+interface ServicesAccessor {
+    get<T>(id: ServiceIdentifier<T>): T;
+}
+/**
+ * Identifies a service of type `T`.
+ */
+interface ServiceIdentifier<T> {
+    (...args: any[]): void;
+    type: T;
+}
+
+interface IContextKey<T> {
+    set(value: T): void;
+    reset(): void;
+    get(): T | undefined;
+}
+
+/**
+ * Configuration options for auto closing quotes and brackets
+ */
+declare type EditorAutoClosingStrategy = 'always' | 'languageDefined' | 'beforeWhitespace' | 'never';
+/**
+ * Configuration options for auto wrapping quotes and brackets
+ */
+declare type EditorAutoSurroundStrategy = 'languageDefined' | 'quotes' | 'brackets' | 'never';
+/**
+ * Configuration options for typing over closing quotes or brackets
+ */
+declare type EditorAutoClosingEditStrategy = 'always' | 'auto' | 'never';
+/**
+ * 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;
+    /**
+     * 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 true.
+    */
+    renderFinalNewline?: boolean;
+    /**
+     * 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 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 false.
+     */
+    cursorSmoothCaretAnimation?: boolean;
+    /**
+     * 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;
+    /**
+     * 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 an interval to check if its container dom node size has changed.
+     * Enabling this might have a severe performance impact.
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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';
+    /**
+     * 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' | '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 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;
+    /**
+     * 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;
+}
+interface IDiffEditorBaseOptions {
+    /**
+     * Allow the user to resize the diff editor split view.
+     * Defaults to true.
+     */
+    enableSplitViewResizing?: boolean;
+    /**
+     * 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;
+    /**
+     * 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';
+}
+/**
+ * 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 automatically restarts from the beginning (or the end) when no further matches can be found
+     */
+    loop?: boolean;
+}
+declare 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;
+}
+/**
+ * Configuration options for editor inlayHints
+ */
+interface IEditorInlayHintsOptions {
+    /**
+     * Enable the inline hints.
+     * Defaults to true.
+     */
+    enabled?: boolean;
+    /**
+     * 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;
+}
+/**
+ * Configuration options for editor minimap
+ */
+interface IEditorMinimapOptions {
+    /**
+     * Enable the rendering of the minimap.
+     * Defaults to true.
+     */
+    enabled?: 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;
+}
+/**
+ * Configuration options for quick suggestions
+ */
+interface IQuickSuggestionsOptions {
+    other?: boolean;
+    comments?: boolean;
+    strings?: boolean;
+}
+declare 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;
+}
+declare 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';
+}
+interface IBracketPairColorizationOptions {
+    /**
+     * Enable or disable bracket pair colorization.
+    */
+    enabled?: 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;
+}
+/**
+ * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+}
+
+/**
+ * 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): boolean;
+    /**
+     * Test if range `a` equals `b`.
+     */
+    static equalsRange(a: IRange | null, b: IRange | null): 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;
+    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 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;
+}
+
+interface IMarkdownString {
+    readonly value: string;
+    readonly isTrusted?: boolean;
+    readonly supportThemeIcons?: boolean;
+    readonly supportHtml?: boolean;
+    readonly baseUri?: UriComponents;
+    uris?: {
+        [href: string]: UriComponents;
+    };
+}
+
+interface ThemeColor {
+    id: string;
+}
+declare namespace ThemeColor {
+    function isThemeColor(obj: any): obj is ThemeColor;
+}
+
+/**
+ * Vertical Lane in the overview ruler of the editor.
+ */
+declare enum OverviewRulerLane {
+    Left = 1,
+    Center = 2,
+    Right = 4,
+    Full = 7
+}
+/**
+ * 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;
+}
+/**
+ * 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 overview ruler.
+ */
+interface IModelDecorationMinimapOptions extends IDecorationOptions {
+    /**
+     * The position in the overview ruler.
+     */
+    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;
+    /**
+     * 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).
+     * @internal
+     */
+    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, 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;
+}
+/**
+ * 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: string[], newDecorations: IModelDeltaDecoration[]): string[];
+}
+/**
+ * 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
+}
+/**
+ * A model.
+ */
+type ITextModel = monaco.editor.ITextModel
+
+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(): Promise<void>;
+}
+declare 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.
+ */
+declare 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): 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;
+    /**
+     * 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;
+}
+
+interface IDiffComputationResult {
+    quitEarly: boolean;
+    identical: boolean;
+    changes: ILineChange[];
+}
+/**
+ * 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 IDiffEditorConstructionOptions extends IDiffEditorOptions {
+    /**
+     * The initial editor dimension (to avoid measuring the container).
+     */
+    dimension?: IDimension;
+    /**
+     * Place overflow widgets inside an external DOM node.
+     * Defaults to an internal DOM node.
+     */
+    overflowWidgetsDomNode?: HTMLElement;
+    /**
+     * Aria label for original editor.
+     */
+    originalAriaLabel?: string;
+    /**
+     * Aria label for modified editor.
+     */
+    modifiedAriaLabel?: string;
+    /**
+     * Is the diff editor inside another editor
+     * Defaults to false
+     */
+    isInEmbeddedEditor?: boolean;
+}
+/**
+ * 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>;
+    /**
+     * 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): 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;
+}
+
+interface IEditorConstructionOptions extends IEditorOptions {
+    /**
+     * The initial editor dimension (to avoid measuring the container).
+     */
+    dimension?: IDimension;
+    /**
+     * Place overflow widgets inside an external DOM node.
+     * Defaults to an internal DOM node.
+     */
+    overflowWidgetsDomNode?: HTMLElement;
+}
+
+interface ICommandHandler {
+    (accessor: ServicesAccessor, ...args: any[]): void;
+}
+
+/**
+ * Description of an action contribution
+ */
+interface IActionDescriptor {
+    /**
+     * An unique identifier of the contributed action.
+     */
+    id: string;
+    /**
+     * A label of the action that will be presented to the user.
+     */
+    label: string;
+    /**
+     * Precondition rule.
+     */
+    precondition?: string;
+    /**
+     * An array of keybindings for the action.
+     */
+    keybindings?: number[];
+    /**
+     * The keybinding rule (condition on top of precondition).
+     */
+    keybindingContext?: string;
+    /**
+     * Control if the action should show up in the context menu and where.
+     * The context menu of the editor has these default:
+     *   navigation - The navigation group comes first in all cases.
+     *   1_modification - This group comes next and contains commands that modify your code.
+     *   9_cutcopypaste - The last default group with the basic editing commands.
+     * You can also create your own group.
+     * Defaults to null (don't show in context menu).
+     */
+    contextMenuGroupId?: string;
+    /**
+     * Control the order in the context menu group.
+     */
+    contextMenuOrder?: number;
+    /**
+     * Method that will be executed when the action is triggered.
+     * @param editor The editor instance is passed in as a convenience
+     */
+    run(editor: ICodeEditor, ...args: any[]): void | Promise<void>;
+}
+/**
+ * Options which apply for all editors.
+ */
+interface IGlobalEditorOptions {
+    /**
+     * The number of spaces a tab is equal to.
+     * This setting is overridden based on the file contents when `detectIndentation` is on.
+     * Defaults to 4.
+     */
+    tabSize?: number;
+    /**
+     * Insert spaces when pressing `Tab`.
+     * This setting is overridden based on the file contents when `detectIndentation` is on.
+     * Defaults to true.
+     */
+    insertSpaces?: boolean;
+    /**
+     * Controls whether `tabSize` and `insertSpaces` will be automatically detected when a file is opened based on the file contents.
+     * Defaults to true.
+     */
+    detectIndentation?: boolean;
+    /**
+     * Remove trailing auto inserted whitespace.
+     * Defaults to true.
+     */
+    trimAutoWhitespace?: boolean;
+    /**
+     * Special handling for large files to disable certain memory intensive features.
+     * Defaults to true.
+     */
+    largeFileOptimizations?: boolean;
+    /**
+     * Controls whether completions should be computed based on words in the document.
+     * Defaults to true.
+     */
+    wordBasedSuggestions?: boolean;
+    /**
+     * Controls whether word based completions should be included from opened documents of the same language or any language.
+     */
+    wordBasedSuggestionsOnlySameLanguage?: boolean;
+    /**
+     * Controls whether the semanticHighlighting is shown for the languages that support it.
+     * true: semanticHighlighting is enabled for all themes
+     * false: semanticHighlighting is disabled for all themes
+     * 'configuredByTheme': semanticHighlighting is controlled by the current color theme's semanticHighlighting setting.
+     * Defaults to 'byTheme'.
+     */
+    'semanticHighlighting.enabled'?: true | false | 'configuredByTheme';
+    /**
+     * Keep peek editors open even when double clicking their content or when hitting `Escape`.
+     * Defaults to false.
+     */
+    stablePeek?: boolean;
+    /**
+     * Lines above this length will not be tokenized for performance reasons.
+     * Defaults to 20000.
+     */
+    maxTokenizationLineLength?: number;
+    /**
+     * Theme to be used for rendering.
+     * The current out-of-the-box available themes are: 'vs' (default), 'vs-dark', 'hc-black'.
+     * You can create custom themes via `monaco.editor.defineTheme`.
+     * To switch a theme, use `monaco.editor.setTheme`.
+     * **NOTE**: The theme might be overwritten if the OS is in high contrast mode, unless `autoDetectHighContrast` is set to false.
+     */
+    theme?: string;
+    /**
+     * If enabled, will automatically change to high contrast theme if the OS is using a high contrast theme.
+     * Defaults to true.
+     */
+    autoDetectHighContrast?: boolean;
+}
+/**
+ * The options to create an editor.
+ */
+interface IStandaloneEditorConstructionOptions extends IEditorConstructionOptions, IGlobalEditorOptions {
+    /**
+     * The initial model associated with this code editor.
+     */
+    model?: ITextModel | null;
+    /**
+     * The initial value of the auto created model in the editor.
+     * To not automatically create a model, use `model: null`.
+     */
+    value?: string;
+    /**
+     * The initial language of the auto created model in the editor.
+     * To not automatically create a model, use `model: null`.
+     */
+    language?: string;
+    /**
+     * Initial theme to be used for rendering.
+     * The current out-of-the-box available themes are: 'vs' (default), 'vs-dark', 'hc-black'.
+     * You can create custom themes via `monaco.editor.defineTheme`.
+     * To switch a theme, use `monaco.editor.setTheme`.
+     * **NOTE**: The theme might be overwritten if the OS is in high contrast mode, unless `autoDetectHighContrast` is set to false.
+     */
+    theme?: string;
+    /**
+     * If enabled, will automatically change to high contrast theme if the OS is using a high contrast theme.
+     * Defaults to true.
+     */
+    autoDetectHighContrast?: boolean;
+    /**
+     * An URL to open when Ctrl+H (Windows and Linux) or Cmd+H (OSX) is pressed in
+     * the accessibility help dialog in the editor.
+     *
+     * Defaults to "https://go.microsoft.com/fwlink/?linkid=852450"
+     */
+    accessibilityHelpUrl?: string;
+    /**
+     * Container element to use for ARIA messages.
+     * Defaults to document.body.
+     */
+    ariaContainerElement?: HTMLElement;
+}
+/**
+ * The options to create a diff editor.
+ */
+interface IStandaloneDiffEditorConstructionOptions extends IDiffEditorConstructionOptions {
+    /**
+     * Initial theme to be used for rendering.
+     * The current out-of-the-box available themes are: 'vs' (default), 'vs-dark', 'hc-black'.
+     * You can create custom themes via `monaco.editor.defineTheme`.
+     * To switch a theme, use `monaco.editor.setTheme`.
+     * **NOTE**: The theme might be overwritten if the OS is in high contrast mode, unless `autoDetectHighContrast` is set to false.
+     */
+    theme?: string;
+    /**
+     * If enabled, will automatically change to high contrast theme if the OS is using a high contrast theme.
+     * Defaults to true.
+     */
+    autoDetectHighContrast?: boolean;
+}
+interface IStandaloneCodeEditor extends ICodeEditor {
+    updateOptions(newOptions: IEditorOptions & IGlobalEditorOptions): void;
+    addCommand(keybinding: number, handler: ICommandHandler, context?: string): string | null;
+    createContextKey<T>(key: string, defaultValue: T): IContextKey<T>;
+    addAction(descriptor: IActionDescriptor): IDisposable;
+}
+interface IStandaloneDiffEditor extends IDiffEditor {
+    addCommand(keybinding: number, handler: ICommandHandler, context?: string): string | null;
+    createContextKey<T>(key: string, defaultValue: T): IContextKey<T>;
+    addAction(descriptor: IActionDescriptor): IDisposable;
+    getOriginalEditor(): IStandaloneCodeEditor;
+    getModifiedEditor(): IStandaloneCodeEditor;
+}
+
+type IEditorOverrideServices = monaco.editor.IEditorOverrideServices
+
+/**
+ * Create a new editor under `domElement`.
+ * `domElement` should be empty (not contain other dom nodes).
+ * The editor will read the size of `domElement`.
+ */
+declare function create(domElement: HTMLElement, options?: IStandaloneEditorConstructionOptions, override?: IEditorOverrideServices): IStandaloneCodeEditor;
+/**
+ * Create a new diff editor under `domElement`.
+ * `domElement` should be empty (not contain other dom nodes).
+ * The editor will read the size of `domElement`.
+ */
+declare function createDiffEditor(domElement: HTMLElement, options?: IStandaloneDiffEditorConstructionOptions, override?: IEditorOverrideServices): IStandaloneDiffEditor;
+
+declare const createConfiguredEditor: typeof create;
+declare const createConfiguredDiffEditor: typeof createDiffEditor;
+
+export { createConfiguredDiffEditor, createConfiguredEditor };