@ng-util/monaco-editor 14.0.1 → 16.0.0

package/monaco.d.ts

@@ -308,116 +308,121 @@ declare namespace monaco {
         F17 = 75,
         F18 = 76,
         F19 = 77,
-        NumLock = 78,
-        ScrollLock = 79,
+        F20 = 78,
+        F21 = 79,
+        F22 = 80,
+        F23 = 81,
+        F24 = 82,
+        NumLock = 83,
+        ScrollLock = 84,
         /**
          * Used for miscellaneous characters; it can vary by keyboard.
          * For the US standard keyboard, the ';:' key
          */
-        Semicolon = 80,
+        Semicolon = 85,
         /**
          * For any country/region, the '+' key
          * For the US standard keyboard, the '=+' key
          */
-        Equal = 81,
+        Equal = 86,
         /**
          * For any country/region, the ',' key
          * For the US standard keyboard, the ',<' key
          */
-        Comma = 82,
+        Comma = 87,
         /**
          * For any country/region, the '-' key
          * For the US standard keyboard, the '-_' key
          */
-        Minus = 83,
+        Minus = 88,
         /**
          * For any country/region, the '.' key
          * For the US standard keyboard, the '.>' key
          */
-        Period = 84,
+        Period = 89,
         /**
          * Used for miscellaneous characters; it can vary by keyboard.
          * For the US standard keyboard, the '/?' key
          */
-        Slash = 85,
+        Slash = 90,
         /**
          * Used for miscellaneous characters; it can vary by keyboard.
          * For the US standard keyboard, the '`~' key
          */
-        Backquote = 86,
+        Backquote = 91,
         /**
          * Used for miscellaneous characters; it can vary by keyboard.
          * For the US standard keyboard, the '[{' key
          */
-        BracketLeft = 87,
+        BracketLeft = 92,
         /**
          * Used for miscellaneous characters; it can vary by keyboard.
          * For the US standard keyboard, the '\|' key
          */
-        Backslash = 88,
+        Backslash = 93,
         /**
          * Used for miscellaneous characters; it can vary by keyboard.
          * For the US standard keyboard, the ']}' key
          */
-        BracketRight = 89,
+        BracketRight = 94,
         /**
          * Used for miscellaneous characters; it can vary by keyboard.
          * For the US standard keyboard, the ''"' key
          */
-        Quote = 90,
+        Quote = 95,
         /**
          * Used for miscellaneous characters; it can vary by keyboard.
          */
-        OEM_8 = 91,
+        OEM_8 = 96,
         /**
          * Either the angle bracket key or the backslash key on the RT 102-key keyboard.
          */
-        IntlBackslash = 92,
-        Numpad0 = 93,
-        Numpad1 = 94,
-        Numpad2 = 95,
-        Numpad3 = 96,
-        Numpad4 = 97,
-        Numpad5 = 98,
-        Numpad6 = 99,
-        Numpad7 = 100,
-        Numpad8 = 101,
-        Numpad9 = 102,
-        NumpadMultiply = 103,
-        NumpadAdd = 104,
-        NUMPAD_SEPARATOR = 105,
-        NumpadSubtract = 106,
-        NumpadDecimal = 107,
-        NumpadDivide = 108,
+        IntlBackslash = 97,
+        Numpad0 = 98,
+        Numpad1 = 99,
+        Numpad2 = 100,
+        Numpad3 = 101,
+        Numpad4 = 102,
+        Numpad5 = 103,
+        Numpad6 = 104,
+        Numpad7 = 105,
+        Numpad8 = 106,
+        Numpad9 = 107,
+        NumpadMultiply = 108,
+        NumpadAdd = 109,
+        NUMPAD_SEPARATOR = 110,
+        NumpadSubtract = 111,
+        NumpadDecimal = 112,
+        NumpadDivide = 113,
         /**
          * Cover all key codes when IME is processing input.
          */
-        KEY_IN_COMPOSITION = 109,
-        ABNT_C1 = 110,
-        ABNT_C2 = 111,
-        AudioVolumeMute = 112,
-        AudioVolumeUp = 113,
-        AudioVolumeDown = 114,
-        BrowserSearch = 115,
-        BrowserHome = 116,
-        BrowserBack = 117,
-        BrowserForward = 118,
-        MediaTrackNext = 119,
-        MediaTrackPrevious = 120,
-        MediaStop = 121,
-        MediaPlayPause = 122,
-        LaunchMediaPlayer = 123,
-        LaunchMail = 124,
-        LaunchApp2 = 125,
+        KEY_IN_COMPOSITION = 114,
+        ABNT_C1 = 115,
+        ABNT_C2 = 116,
+        AudioVolumeMute = 117,
+        AudioVolumeUp = 118,
+        AudioVolumeDown = 119,
+        BrowserSearch = 120,
+        BrowserHome = 121,
+        BrowserBack = 122,
+        BrowserForward = 123,
+        MediaTrackNext = 124,
+        MediaTrackPrevious = 125,
+        MediaStop = 126,
+        MediaPlayPause = 127,
+        LaunchMediaPlayer = 128,
+        LaunchMail = 129,
+        LaunchApp2 = 130,
         /**
          * VK_CLEAR, 0x0C, CLEAR key
          */
-        Clear = 126,
+        Clear = 131,
         /**
          * Placed last to cover the length of the enum.
          * Please do not depend on this value!
          */
-        MAX_VALUE = 127
+        MAX_VALUE = 132
     }
     export class KeyMod {
         static readonly CtrlCmd: number;
@@ -429,7 +434,7 @@ declare namespace monaco {
 
     export interface IMarkdownString {
         readonly value: string;
-        readonly isTrusted?: boolean;
+        readonly isTrusted?: boolean | MarkdownStringTrustedOptions;
         readonly supportThemeIcons?: boolean;
         readonly supportHtml?: boolean;
         readonly baseUri?: UriComponents;
@@ -438,6 +443,10 @@ declare namespace monaco {
         };
     }
 
+    export interface MarkdownStringTrustedOptions {
+        readonly enabledCommands: readonly string[];
+    }
+
     export interface IKeyboardEvent {
         readonly _standardKeyboardEventBrand: true;
         readonly browserEvent: KeyboardEvent;
@@ -446,6 +455,7 @@ declare namespace monaco {
         readonly shiftKey: boolean;
         readonly altKey: boolean;
         readonly metaKey: boolean;
+        readonly altGraphKey: boolean;
         readonly keyCode: KeyCode;
         readonly code: string;
         equals(keybinding: number): boolean;
@@ -668,11 +678,11 @@ declare namespace monaco {
         /**
          * Test if this range equals other.
          */
-        equalsRange(other: IRange | null): boolean;
+        equalsRange(other: IRange | null | undefined): boolean;
         /**
          * Test if range `a` equals `b`.
          */
-        static equalsRange(a: IRange | null, b: IRange | null): boolean;
+        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)
          */
@@ -709,6 +719,18 @@ declare namespace monaco {
          * 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`.
@@ -863,10 +885,10 @@ declare namespace monaco {
     }
 
     export class Token {
-        _tokenBrand: void;
         readonly offset: number;
         readonly type: string;
         readonly language: string;
+        _tokenBrand: void;
         constructor(offset: number, type: string, language: string);
         toString(): string;
     }
@@ -895,6 +917,22 @@ declare namespace monaco.editor {
      */
     export function onDidCreateEditor(listener: (codeEditor: ICodeEditor) => void): IDisposable;
 
+    /**
+     * Emitted when an diff editor is created.
+     * @event
+     */
+    export function onDidCreateDiffEditor(listener: (diffEditor: IDiffEditor) => void): IDisposable;
+
+    /**
+     * Get all the created editors.
+     */
+    export function getEditors(): readonly ICodeEditor[];
+
+    /**
+     * Get all the created diff editors.
+     */
+    export function getDiffEditors(): readonly IDiffEditor[];
+
     /**
      * Create a new diff editor under `domElement`.
      * `domElement` should be empty (not contain other dom nodes).
@@ -910,6 +948,50 @@ declare namespace monaco.editor {
 
     export function createDiffNavigator(diffEditor: IStandaloneDiffEditor, opts?: IDiffNavigatorOptions): IDiffNavigator;
 
+    /**
+     * Description of a command contribution
+     */
+    export interface ICommandDescriptor {
+        /**
+         * An unique identifier of the contributed command.
+         */
+        id: string;
+        /**
+         * Callback that will be executed when the command is triggered.
+         */
+        run: ICommandHandler;
+    }
+
+    /**
+     * Add a command.
+     */
+    export function addCommand(descriptor: ICommandDescriptor): IDisposable;
+
+    /**
+     * Add an action to all editors.
+     */
+    export function addEditorAction(descriptor: IActionDescriptor): IDisposable;
+
+    /**
+     * A keybinding rule.
+     */
+    export interface IKeybindingRule {
+        keybinding: number;
+        command?: string | null;
+        commandArgs?: any;
+        when?: string | null;
+    }
+
+    /**
+     * Add a keybinding rule.
+     */
+    export function addKeybindingRule(rule: IKeybindingRule): IDisposable;
+
+    /**
+     * Add keybinding rules.
+     */
+    export function addKeybindingRules(rules: IKeybindingRule[]): IDisposable;
+
     /**
      * Create a new editor model.
      * You can specify the language that should be set for this model or let the language be inferred from the `uri`.
@@ -919,13 +1001,18 @@ declare namespace monaco.editor {
     /**
      * Change the language for a model.
      */
-    export function setModelLanguage(model: ITextModel, languageId: string): void;
+    export function setModelLanguage(model: ITextModel, mimeTypeOrLanguageId: string): void;
 
     /**
      * Set the markers for a model.
      */
     export function setModelMarkers(model: ITextModel, owner: string, markers: IMarkerData[]): void;
 
+    /**
+     * Remove all markers of an owner.
+     */
+    export function removeAllMarkers(owner: string): void;
+
     /**
      * Get markers for owner and/or resource
      *
@@ -978,7 +1065,7 @@ declare namespace monaco.editor {
      * Create a new web worker that has model syncing capabilities built in.
      * Specify an AMD module to load that will `create` an object that will be proxied.
      */
-    export function createWebWorker<T>(opts: IWebWorkerOptions): MonacoWebWorker<T>;
+    export function createWebWorker<T extends object>(opts: IWebWorkerOptions): MonacoWebWorker<T>;
 
     /**
      * Colorize the contents of `domNode` using attribute `data-lang`.
@@ -1020,7 +1107,44 @@ declare namespace monaco.editor {
      */
     export function registerCommand(id: string, handler: (accessor: any, ...args: any[]) => void): IDisposable;
 
-    export type BuiltinTheme = 'vs' | 'vs-dark' | 'hc-black';
+    export interface ILinkOpener {
+        open(resource: Uri): boolean | Promise<boolean>;
+    }
+
+    /**
+     * Registers a handler that is called when a link is opened in any editor. The handler callback should return `true` if the link was handled and `false` otherwise.
+     * The handler that was registered last will be called first when a link is opened.
+     *
+     * Returns a disposable that can unregister the opener again.
+     */
+    export function registerLinkOpener(opener: ILinkOpener): IDisposable;
+
+    /**
+     * Represents an object that can handle editor open operations (e.g. when "go to definition" is called
+     * with a resource other than the current model).
+     */
+    export interface ICodeEditorOpener {
+        /**
+         * Callback that is invoked when a resource other than the current model should be opened (e.g. when "go to definition" is called).
+         * The callback should return `true` if the request was handled and `false` otherwise.
+         * @param source The code editor instance that initiated the request.
+         * @param resource The Uri of the resource that should be opened.
+         * @param selectionOrPosition An optional position or selection inside the model corresponding to `resource` that can be used to set the cursor.
+         */
+        openCodeEditor(source: ICodeEditor, resource: Uri, selectionOrPosition?: IRange | IPosition): boolean | Promise<boolean>;
+    }
+
+    /**
+     * Registers a handler that is called when a resource other than the current model should be opened in the editor (e.g. "go to definition").
+     * The handler callback should return `true` if the request was handled and `false` otherwise.
+     *
+     * Returns a disposable that can unregister the opener again.
+     *
+     * If no handler is registered the default behavior is to do nothing for models other than the currently attached one.
+     */
+    export function registerEditorOpener(opener: ICodeEditorOpener): IDisposable;
+
+    export type BuiltinTheme = 'vs' | 'vs-dark' | 'hc-black' | 'hc-light';
 
     export interface IStandaloneThemeData {
         base: BuiltinTheme;
@@ -1179,7 +1303,7 @@ declare namespace monaco.editor {
          */
         'semanticHighlighting.enabled'?: true | false | 'configuredByTheme';
         /**
-         * Keep peek editors open even when double clicking their content or when hitting `Escape`.
+         * Keep peek editors open even when double-clicking their content or when hitting `Escape`.
          * Defaults to false.
          */
         stablePeek?: boolean;
@@ -1190,7 +1314,7 @@ declare namespace monaco.editor {
         maxTokenizationLineLength?: number;
         /**
          * Theme to be used for rendering.
-         * The current out-of-the-box available themes are: 'vs' (default), 'vs-dark', 'hc-black'.
+         * The current out-of-the-box available themes are: 'vs' (default), 'vs-dark', 'hc-black', 'hc-light'.
          * 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.
@@ -1223,7 +1347,7 @@ declare namespace monaco.editor {
         language?: string;
         /**
          * Initial theme to be used for rendering.
-         * The current out-of-the-box available themes are: 'vs' (default), 'vs-dark', 'hc-black'.
+         * The current out-of-the-box available themes are: 'vs' (default), 'vs-dark', 'hc-black', 'hc-light.
          * 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.
@@ -1254,7 +1378,7 @@ declare namespace monaco.editor {
     export 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'.
+         * The current out-of-the-box available themes are: 'vs' (default), 'vs-dark', 'hc-black', 'hc-light.
          * 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.
@@ -1270,13 +1394,13 @@ declare namespace monaco.editor {
     export 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>;
+        createContextKey<T extends ContextKeyValue = ContextKeyValue>(key: string, defaultValue: T): IContextKey<T>;
         addAction(descriptor: IActionDescriptor): IDisposable;
     }
 
     export interface IStandaloneDiffEditor extends IDiffEditor {
         addCommand(keybinding: number, handler: ICommandHandler, context?: string): string | null;
-        createContextKey<T>(key: string, defaultValue: T): IContextKey<T>;
+        createContextKey<T extends ContextKeyValue = ContextKeyValue>(key: string, defaultValue: T): IContextKey<T>;
         addAction(descriptor: IActionDescriptor): IDisposable;
         getOriginalEditor(): IStandaloneCodeEditor;
         getModifiedEditor(): IStandaloneCodeEditor;
@@ -1285,12 +1409,14 @@ declare namespace monaco.editor {
         (...args: any[]): void;
     }
 
-    export interface IContextKey<T> {
+    export interface IContextKey<T extends ContextKeyValue = ContextKeyValue> {
         set(value: T): void;
         reset(): void;
         get(): T | undefined;
     }
 
+    export type ContextKeyValue = null | undefined | boolean | number | string | Array<null | undefined | boolean | number | string> | Record<string, null | undefined | boolean | number | string>;
+
     export interface IEditorOverrideServices {
         [index: string]: any;
     }
@@ -1309,6 +1435,7 @@ declare namespace monaco.editor {
         startColumn: number;
         endLineNumber: number;
         endColumn: number;
+        modelVersionId?: number;
         relatedInformation?: IRelatedInformation[];
         tags?: MarkerTag[];
     }
@@ -1328,6 +1455,7 @@ declare namespace monaco.editor {
         startColumn: number;
         endLineNumber: number;
         endColumn: number;
+        modelVersionId?: number;
         relatedInformation?: IRelatedInformation[];
         tags?: MarkerTag[];
     }
@@ -1411,6 +1539,14 @@ declare namespace monaco.editor {
         Full = 7
     }
 
+    /**
+     * Vertical Lane in the glyph margin of the editor.
+     */
+    export enum GlyphMarginLane {
+        Left = 1,
+        Right = 2
+    }
+
     /**
      * Position in the minimap to render the decoration.
      */
@@ -1432,6 +1568,13 @@ declare namespace monaco.editor {
         darkColor?: string | ThemeColor;
     }
 
+    export interface IModelDecorationGlyphMarginOptions {
+        /**
+         * The position in the glyph margin.
+         */
+        position: GlyphMarginLane;
+    }
+
     /**
      * Options for rendering a model decoration in the overview ruler.
      */
@@ -1443,11 +1586,11 @@ declare namespace monaco.editor {
     }
 
     /**
-     * Options for rendering a model decoration in the overview ruler.
+     * Options for rendering a model decoration in the minimap.
      */
     export interface IModelDecorationMinimapOptions extends IDecorationOptions {
         /**
-         * The position in the overview ruler.
+         * The position in the minimap.
          */
         position: MinimapPosition;
     }
@@ -1465,6 +1608,14 @@ declare namespace monaco.editor {
          * 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.
          */
@@ -1477,6 +1628,10 @@ declare namespace monaco.editor {
          * 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;
         /**
          * Specifies the stack order of a decoration.
          * A decoration with greater stack order is always in front of a decoration with
@@ -1495,6 +1650,11 @@ declare namespace monaco.editor {
          * 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.
          */
@@ -1687,15 +1847,17 @@ declare namespace monaco.editor {
         readonly defaultEOL: DefaultEndOfLine;
         readonly trimAutoWhitespace: boolean;
         readonly bracketPairColorizationOptions: BracketPairColorizationOptions;
+        get originalIndentSize(): number | 'tabSize';
     }
 
     export interface BracketPairColorizationOptions {
         enabled: boolean;
+        independentColorPoolPerBracketType: boolean;
     }
 
     export interface ITextModelUpdateOptions {
         tabSize?: number;
-        indentSize?: number;
+        indentSize?: number | 'tabSize';
         insertSpaces?: boolean;
         trimAutoWhitespace?: boolean;
         bracketColorizationOptions?: BracketPairColorizationOptions;
@@ -1718,6 +1880,15 @@ declare namespace monaco.editor {
         GrowsOnlyWhenTypingAfter = 3
     }
 
+    /**
+     * Text snapshot that works like an iterator.
+     * Will try to return chunks of roughly ~64KB size.
+     * Will return null when finished.
+     */
+    export interface ITextSnapshot {
+        read(): string | null;
+    }
+
     /**
      * A model.
      */
@@ -1749,7 +1920,7 @@ declare namespace monaco.editor {
         /**
          * Replace the entire text buffer value contained in this model.
          */
-        setValue(newValue: string): void;
+        setValue(newValue: string | ITextSnapshot): void;
         /**
          * Get the text stored in this model.
          * @param eol The end of line character preference. Defaults to `EndOfLinePreference.TextDefined`.
@@ -1757,6 +1928,12 @@ declare namespace monaco.editor {
          * @return The text.
          */
         getValue(eol?: EndOfLinePreference, preserveBOM?: boolean): string;
+        /**
+         * Get the text stored in this model.
+         * @param preserverBOM Preserve a BOM character if it was detected when the model was constructed.
+         * @return The text snapshot (it is safe to consume it asynchronously).
+         */
+        createSnapshot(preserveBOM?: boolean): ITextSnapshot;
         /**
          * Get the length of the text stored in this model.
          */
@@ -1773,12 +1950,12 @@ declare namespace monaco.editor {
          * @param range The range describing what text length to get.
          * @return The text length.
          */
-        getValueLengthInRange(range: IRange): number;
+        getValueLengthInRange(range: IRange, eol?: EndOfLinePreference): number;
         /**
          * Get the character count of text in a certain range.
          * @param range The range describing what text length to get.
          */
-        getCharacterCountInRange(range: IRange): number;
+        getCharacterCountInRange(range: IRange, eol?: EndOfLinePreference): number;
         /**
          * Get the number of lines in the model.
          */
@@ -1973,15 +2150,22 @@ declare namespace monaco.editor {
          * @param range The range to search in
          * @param ownerId If set, it will ignore decorations belonging to other owners.
          * @param filterOutValidation If set, it will ignore decorations specific to validation (i.e. warnings, errors).
+         * @param onlyMinimapDecorations If set, it will return only decorations that render in the minimap.
+         * @param onlyMarginDecorations If set, it will return only decorations that render in the glyph margin.
          * @return An array with the decorations
          */
-        getDecorationsInRange(range: IRange, ownerId?: number, filterOutValidation?: boolean): IModelDecoration[];
+        getDecorationsInRange(range: IRange, ownerId?: number, filterOutValidation?: boolean, onlyMinimapDecorations?: boolean, onlyMarginDecorations?: boolean): IModelDecoration[];
         /**
          * Gets all the decorations as an array.
          * @param ownerId If set, it will ignore decorations belonging to other owners.
          * @param filterOutValidation If set, it will ignore decorations specific to validation (i.e. warnings, errors).
          */
         getAllDecorations(ownerId?: number, filterOutValidation?: boolean): IModelDecoration[];
+        /**
+         * Gets all decorations that render in the glyph margin as an array.
+         * @param ownerId If set, it will ignore decorations belonging to other owners.
+         */
+        getAllMarginDecorations(ownerId?: number): IModelDecoration[];
         /**
          * Gets all the decorations that should be rendered in the overview ruler as an array.
          * @param ownerId If set, it will ignore decorations belonging to other owners.
@@ -2100,7 +2284,15 @@ declare namespace monaco.editor {
         /**
          * No preference.
         */
-        None = 2
+        None = 2,
+        /**
+         * If the given position is on injected text, prefers the position left of it.
+        */
+        LeftOfInjectedText = 3,
+        /**
+         * If the given position is on injected text, prefers the position right of it.
+        */
+        RightOfInjectedText = 4
     }
 
     /**
@@ -2129,6 +2321,144 @@ declare namespace monaco.editor {
     export interface ILineChange extends IChange {
         readonly charChanges: ICharChange[] | undefined;
     }
+
+    /**
+     * A document diff provider computes the diff between two text models.
+     */
+    export 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: IEvent<void>;
+    }
+
+    /**
+     * Options for the diff computation.
+     */
+    export 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.
+     */
+    export 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[];
+    }
+    /**
+     * A range of lines (1-based).
+     */
+    export 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.
+     */
+    export 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(): any;
+    }
+
+    /**
+     * Maps a range in the original text model to a range in the modified text model.
+     */
+    export class RangeMapping {
+        /**
+         * The original range.
+         */
+        readonly originalRange: Range;
+        /**
+         * The modified range.
+         */
+        readonly modifiedRange: Range;
+        constructor(originalRange: Range, modifiedRange: Range);
+        toString(): string;
+    }
     export interface IDimension {
         width: number;
         height: number;
@@ -2243,7 +2573,7 @@ declare namespace monaco.editor {
         readonly label: string;
         readonly alias: string;
         isSupported(): boolean;
-        run(): Promise<void>;
+        run(args?: unknown): Promise<void>;
     }
 
     export type IEditorModel = ITextModel | IDiffEditorModel;
@@ -2351,7 +2681,7 @@ declare namespace monaco.editor {
         /**
          * Restores the view state of the editor from a serializable object generated by `saveViewState`.
          */
-        restoreViewState(state: IEditorViewState): void;
+        restoreViewState(state: IEditorViewState | null): void;
         /**
          * Given a position, returns a column number that takes tab-widths into account.
          */
@@ -2502,6 +2832,47 @@ declare namespace monaco.editor {
          * 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;
+    }
+
+    /**
+     * A collection of decorations
+     */
+    export 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: IEvent<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;
     }
 
     /**
@@ -2542,6 +2913,10 @@ declare namespace monaco.editor {
          * New language
          */
         readonly newLanguage: string;
+        /**
+         * Source of the call that caused the event.
+         */
+        readonly source: string;
     }
 
     /**
@@ -2595,6 +2970,10 @@ declare namespace monaco.editor {
          * The model has been reset to a new value.
          */
         readonly isFlush: boolean;
+        /**
+         * Flag that indicates that this event describes an eol change.
+         */
+        readonly isEolChange: boolean;
     }
 
     /**
@@ -2603,6 +2982,7 @@ declare namespace monaco.editor {
     export interface IModelDecorationsChangedEvent {
         readonly affectsMinimap: boolean;
         readonly affectsOverviewRuler: boolean;
+        readonly affectsGlyphMargin: boolean;
     }
 
     export interface IModelOptionsChangedEvent {
@@ -2749,6 +3129,10 @@ declare namespace monaco.editor {
          * 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
          */
@@ -2789,9 +3173,9 @@ declare namespace monaco.editor {
         cursorSurroundingLinesStyle?: 'default' | 'all';
         /**
          * Render last line number when the file ends with a newline.
-         * Defaults to true.
+         * Defaults to 'on' for Windows and macOS and 'dimmed' for Linux.
         */
-        renderFinalNewline?: boolean;
+        renderFinalNewline?: 'on' | 'off' | 'dimmed';
         /**
          * Remove unusual line terminators like LINE SEPARATOR (LS), PARAGRAPH SEPARATOR (PS).
          * Defaults to 'prompt'.
@@ -2862,6 +3246,10 @@ declare namespace monaco.editor {
          * 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.
          */
@@ -2902,9 +3290,9 @@ declare namespace monaco.editor {
         mouseStyle?: 'text' | 'default' | 'copy';
         /**
          * Enable smooth caret animation.
-         * Defaults to false.
+         * Defaults to 'off'.
          */
-        cursorSmoothCaretAnimation?: boolean;
+        cursorSmoothCaretAnimation?: 'off' | 'explicit' | 'on';
         /**
          * Control the cursor style, either 'block' or 'line'.
          * Defaults to 'line'.
@@ -2919,6 +3307,15 @@ declare namespace monaco.editor {
          * 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.
@@ -2951,8 +3348,7 @@ declare namespace monaco.editor {
          */
         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.
+         * Enable that the editor will install a ResizeObserver to check if its container dom node size has changed.
          * Defaults to false.
          */
         automaticLayout?: boolean;
@@ -3000,6 +3396,12 @@ declare namespace monaco.editor {
          * 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.
@@ -3019,6 +3421,10 @@ declare namespace monaco.editor {
          * 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.
          */
@@ -3063,6 +3469,10 @@ declare namespace monaco.editor {
          * 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'.
@@ -3256,7 +3666,7 @@ declare namespace monaco.editor {
          * 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';
+        showFoldingControls?: 'always' | 'never' | 'mouseover';
         /**
          * Controls whether clicking on the empty content after a folded line will unfold the line.
          * Defaults to false.
@@ -3267,6 +3677,11 @@ declare namespace monaco.editor {
          * 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'.
@@ -3329,6 +3744,10 @@ declare namespace monaco.editor {
          * 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.
          */
@@ -3350,6 +3769,16 @@ declare namespace monaco.editor {
          * 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;
     }
 
     export interface IDiffEditorBaseOptions {
@@ -3358,6 +3787,12 @@ declare namespace monaco.editor {
          * 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.
@@ -3383,6 +3818,11 @@ declare namespace monaco.editor {
          * 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.
@@ -3402,6 +3842,14 @@ declare namespace monaco.editor {
          * 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;
     }
 
     /**
@@ -3431,7 +3879,7 @@ declare namespace monaco.editor {
         /**
          * Might modify `value`.
         */
-        applyUpdate(value: V, update: V): ApplyUpdateResult<V>;
+        applyUpdate(value: V | undefined, update: V): ApplyUpdateResult<V>;
     }
 
     export class ApplyUpdateResult<T> {
@@ -3534,7 +3982,7 @@ declare namespace monaco.editor {
         autoFindInSelection?: 'never' | 'always' | 'multiline';
         addExtraSpaceOnTop?: boolean;
         /**
-         * Controls whether the search automatically restarts from the beginning (or the end) when no further matches can be found
+         * 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;
     }
@@ -3632,6 +4080,10 @@ declare namespace monaco.editor {
          * The width of the glyph margin.
          */
         readonly glyphMarginWidth: number;
+        /**
+         * The number of decoration lanes to render in the glyph margin.
+         */
+        readonly glyphMarginDecorationLaneCount: number;
         /**
          * Left position for the line numbers.
          */
@@ -3709,6 +4161,21 @@ declare namespace monaco.editor {
         enabled?: boolean;
     }
 
+    export 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
      */
@@ -3717,7 +4184,7 @@ declare namespace monaco.editor {
          * Enable the inline hints.
          * Defaults to true.
          */
-        enabled?: boolean;
+        enabled?: 'on' | 'off' | 'offUnlessPressed' | 'onUnlessPressed';
         /**
          * Font size of inline hints.
          * Default to 90% of the editor font size.
@@ -3728,6 +4195,11 @@ declare namespace monaco.editor {
          * Defaults to editor font family.
          */
         fontFamily?: string;
+        /**
+         * Enables the padding around the inlay hint.
+         * Defaults to false.
+         */
+        padding?: boolean;
     }
 
     /**
@@ -3739,6 +4211,10 @@ declare namespace monaco.editor {
          * Defaults to true.
          */
         enabled?: boolean;
+        /**
+         * Control the rendering of minimap.
+         */
+        autohide?: boolean;
         /**
          * Control the side of the minimap in editor.
          * Defaults to 'right'.
@@ -3800,13 +4276,21 @@ declare namespace monaco.editor {
         cycle?: boolean;
     }
 
+    export type QuickSuggestionsValue = 'on' | 'inline' | 'off';
+
     /**
      * Configuration options for quick suggestions
      */
     export interface IQuickSuggestionsOptions {
-        other?: boolean;
-        comments?: boolean;
-        strings?: boolean;
+        other?: boolean | QuickSuggestionsValue;
+        comments?: boolean | QuickSuggestionsValue;
+        strings?: boolean | QuickSuggestionsValue;
+    }
+
+    export interface InternalQuickSuggestionsOptions {
+        readonly other: QuickSuggestionsValue;
+        readonly comments: QuickSuggestionsValue;
+        readonly strings: QuickSuggestionsValue;
     }
 
     export type LineNumbersType = 'on' | 'off' | 'relative' | 'interval' | ((lineNumber: number) => string);
@@ -3972,6 +4456,12 @@ declare namespace monaco.editor {
          * 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;
     }
 
     export interface IBracketPairColorizationOptions {
@@ -3979,6 +4469,10 @@ declare namespace monaco.editor {
          * Enable or disable bracket pair colorization.
         */
         enabled?: boolean;
+        /**
+         * Use independent color pool per bracket type.
+        */
+        independentColorPoolPerBracketType?: boolean;
     }
 
     export interface IGuidesOptions {
@@ -4006,7 +4500,7 @@ declare namespace monaco.editor {
          * Enable highlighting of the active indent guide.
          * Defaults to true.
          */
-        highlightActiveIndentation?: boolean;
+        highlightActiveIndentation?: boolean | 'always';
     }
 
     /**
@@ -4033,6 +4527,10 @@ declare namespace monaco.editor {
          * 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.
          */
@@ -4069,6 +4567,10 @@ declare namespace monaco.editor {
          * 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.
          */
@@ -4200,6 +4702,22 @@ declare namespace monaco.editor {
         readonly wrappingColumn: number;
     }
 
+    /**
+     * Configuration options for editor drop into behavior
+     */
+    export 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';
+    }
+
     export enum EditorOption {
         acceptSuggestionOnCommitCharacter = 0,
         acceptSuggestionOnEnter = 1,
@@ -4207,133 +4725,142 @@ declare namespace monaco.editor {
         accessibilityPageSize = 3,
         ariaLabel = 4,
         autoClosingBrackets = 5,
-        autoClosingDelete = 6,
-        autoClosingOvertype = 7,
-        autoClosingQuotes = 8,
-        autoIndent = 9,
-        automaticLayout = 10,
-        autoSurround = 11,
-        bracketPairColorization = 12,
-        guides = 13,
-        codeLens = 14,
-        codeLensFontFamily = 15,
-        codeLensFontSize = 16,
-        colorDecorators = 17,
-        columnSelection = 18,
-        comments = 19,
-        contextmenu = 20,
-        copyWithSyntaxHighlighting = 21,
-        cursorBlinking = 22,
-        cursorSmoothCaretAnimation = 23,
-        cursorStyle = 24,
-        cursorSurroundingLines = 25,
-        cursorSurroundingLinesStyle = 26,
-        cursorWidth = 27,
-        disableLayerHinting = 28,
-        disableMonospaceOptimizations = 29,
-        domReadOnly = 30,
-        dragAndDrop = 31,
-        emptySelectionClipboard = 32,
-        extraEditorClassName = 33,
-        fastScrollSensitivity = 34,
-        find = 35,
-        fixedOverflowWidgets = 36,
-        folding = 37,
-        foldingStrategy = 38,
-        foldingHighlight = 39,
-        foldingImportsByDefault = 40,
-        foldingMaximumRegions = 41,
-        unfoldOnClickAfterEndOfLine = 42,
-        fontFamily = 43,
-        fontInfo = 44,
-        fontLigatures = 45,
-        fontSize = 46,
-        fontWeight = 47,
-        formatOnPaste = 48,
-        formatOnType = 49,
-        glyphMargin = 50,
-        gotoLocation = 51,
-        hideCursorInOverviewRuler = 52,
-        hover = 53,
-        inDiffEditor = 54,
-        inlineSuggest = 55,
-        letterSpacing = 56,
-        lightbulb = 57,
-        lineDecorationsWidth = 58,
-        lineHeight = 59,
-        lineNumbers = 60,
-        lineNumbersMinChars = 61,
-        linkedEditing = 62,
-        links = 63,
-        matchBrackets = 64,
-        minimap = 65,
-        mouseStyle = 66,
-        mouseWheelScrollSensitivity = 67,
-        mouseWheelZoom = 68,
-        multiCursorMergeOverlapping = 69,
-        multiCursorModifier = 70,
-        multiCursorPaste = 71,
-        occurrencesHighlight = 72,
-        overviewRulerBorder = 73,
-        overviewRulerLanes = 74,
-        padding = 75,
-        parameterHints = 76,
-        peekWidgetDefaultFocus = 77,
-        definitionLinkOpensInPeek = 78,
-        quickSuggestions = 79,
-        quickSuggestionsDelay = 80,
-        readOnly = 81,
-        renameOnType = 82,
-        renderControlCharacters = 83,
-        renderFinalNewline = 84,
-        renderLineHighlight = 85,
-        renderLineHighlightOnlyWhenFocus = 86,
-        renderValidationDecorations = 87,
-        renderWhitespace = 88,
-        revealHorizontalRightPadding = 89,
-        roundedSelection = 90,
-        rulers = 91,
-        scrollbar = 92,
-        scrollBeyondLastColumn = 93,
-        scrollBeyondLastLine = 94,
-        scrollPredominantAxis = 95,
-        selectionClipboard = 96,
-        selectionHighlight = 97,
-        selectOnLineNumbers = 98,
-        showFoldingControls = 99,
-        showUnused = 100,
-        snippetSuggestions = 101,
-        smartSelect = 102,
-        smoothScrolling = 103,
-        stickyTabStops = 104,
-        stopRenderingLineAfter = 105,
-        suggest = 106,
-        suggestFontSize = 107,
-        suggestLineHeight = 108,
-        suggestOnTriggerCharacters = 109,
-        suggestSelection = 110,
-        tabCompletion = 111,
-        tabIndex = 112,
-        unicodeHighlighting = 113,
-        unusualLineTerminators = 114,
-        useShadowDOM = 115,
-        useTabStops = 116,
-        wordSeparators = 117,
-        wordWrap = 118,
-        wordWrapBreakAfterCharacters = 119,
-        wordWrapBreakBeforeCharacters = 120,
-        wordWrapColumn = 121,
-        wordWrapOverride1 = 122,
-        wordWrapOverride2 = 123,
-        wrappingIndent = 124,
-        wrappingStrategy = 125,
-        showDeprecated = 126,
-        inlayHints = 127,
-        editorClassName = 128,
-        pixelRatio = 129,
-        tabFocusMode = 130,
-        layoutInfo = 131,
-        wrappingInfo = 132
+        screenReaderAnnounceInlineSuggestion = 6,
+        autoClosingDelete = 7,
+        autoClosingOvertype = 8,
+        autoClosingQuotes = 9,
+        autoIndent = 10,
+        automaticLayout = 11,
+        autoSurround = 12,
+        bracketPairColorization = 13,
+        guides = 14,
+        codeLens = 15,
+        codeLensFontFamily = 16,
+        codeLensFontSize = 17,
+        colorDecorators = 18,
+        colorDecoratorsLimit = 19,
+        columnSelection = 20,
+        comments = 21,
+        contextmenu = 22,
+        copyWithSyntaxHighlighting = 23,
+        cursorBlinking = 24,
+        cursorSmoothCaretAnimation = 25,
+        cursorStyle = 26,
+        cursorSurroundingLines = 27,
+        cursorSurroundingLinesStyle = 28,
+        cursorWidth = 29,
+        disableLayerHinting = 30,
+        disableMonospaceOptimizations = 31,
+        domReadOnly = 32,
+        dragAndDrop = 33,
+        dropIntoEditor = 34,
+        emptySelectionClipboard = 35,
+        experimentalWhitespaceRendering = 36,
+        extraEditorClassName = 37,
+        fastScrollSensitivity = 38,
+        find = 39,
+        fixedOverflowWidgets = 40,
+        folding = 41,
+        foldingStrategy = 42,
+        foldingHighlight = 43,
+        foldingImportsByDefault = 44,
+        foldingMaximumRegions = 45,
+        unfoldOnClickAfterEndOfLine = 46,
+        fontFamily = 47,
+        fontInfo = 48,
+        fontLigatures = 49,
+        fontSize = 50,
+        fontWeight = 51,
+        fontVariations = 52,
+        formatOnPaste = 53,
+        formatOnType = 54,
+        glyphMargin = 55,
+        gotoLocation = 56,
+        hideCursorInOverviewRuler = 57,
+        hover = 58,
+        inDiffEditor = 59,
+        inlineSuggest = 60,
+        letterSpacing = 61,
+        lightbulb = 62,
+        lineDecorationsWidth = 63,
+        lineHeight = 64,
+        lineNumbers = 65,
+        lineNumbersMinChars = 66,
+        linkedEditing = 67,
+        links = 68,
+        matchBrackets = 69,
+        minimap = 70,
+        mouseStyle = 71,
+        mouseWheelScrollSensitivity = 72,
+        mouseWheelZoom = 73,
+        multiCursorMergeOverlapping = 74,
+        multiCursorModifier = 75,
+        multiCursorPaste = 76,
+        multiCursorLimit = 77,
+        occurrencesHighlight = 78,
+        overviewRulerBorder = 79,
+        overviewRulerLanes = 80,
+        padding = 81,
+        parameterHints = 82,
+        peekWidgetDefaultFocus = 83,
+        definitionLinkOpensInPeek = 84,
+        quickSuggestions = 85,
+        quickSuggestionsDelay = 86,
+        readOnly = 87,
+        renameOnType = 88,
+        renderControlCharacters = 89,
+        renderFinalNewline = 90,
+        renderLineHighlight = 91,
+        renderLineHighlightOnlyWhenFocus = 92,
+        renderValidationDecorations = 93,
+        renderWhitespace = 94,
+        revealHorizontalRightPadding = 95,
+        roundedSelection = 96,
+        rulers = 97,
+        scrollbar = 98,
+        scrollBeyondLastColumn = 99,
+        scrollBeyondLastLine = 100,
+        scrollPredominantAxis = 101,
+        selectionClipboard = 102,
+        selectionHighlight = 103,
+        selectOnLineNumbers = 104,
+        showFoldingControls = 105,
+        showUnused = 106,
+        snippetSuggestions = 107,
+        smartSelect = 108,
+        smoothScrolling = 109,
+        stickyScroll = 110,
+        stickyTabStops = 111,
+        stopRenderingLineAfter = 112,
+        suggest = 113,
+        suggestFontSize = 114,
+        suggestLineHeight = 115,
+        suggestOnTriggerCharacters = 116,
+        suggestSelection = 117,
+        tabCompletion = 118,
+        tabIndex = 119,
+        unicodeHighlighting = 120,
+        unusualLineTerminators = 121,
+        useShadowDOM = 122,
+        useTabStops = 123,
+        wordBreak = 124,
+        wordSeparators = 125,
+        wordWrap = 126,
+        wordWrapBreakAfterCharacters = 127,
+        wordWrapBreakBeforeCharacters = 128,
+        wordWrapColumn = 129,
+        wordWrapOverride1 = 130,
+        wordWrapOverride2 = 131,
+        wrappingIndent = 132,
+        wrappingStrategy = 133,
+        showDeprecated = 134,
+        inlayHints = 135,
+        editorClassName = 136,
+        pixelRatio = 137,
+        tabFocusMode = 138,
+        layoutInfo = 139,
+        wrappingInfo = 140,
+        defaultColorDecorators = 141
     }
 
     export const EditorOptions: {
@@ -4342,6 +4869,7 @@ declare namespace monaco.editor {
         accessibilitySupport: IEditorOption<EditorOption.accessibilitySupport, AccessibilitySupport>;
         accessibilityPageSize: IEditorOption<EditorOption.accessibilityPageSize, number>;
         ariaLabel: IEditorOption<EditorOption.ariaLabel, string>;
+        screenReaderAnnounceInlineSuggestion: IEditorOption<EditorOption.screenReaderAnnounceInlineSuggestion, boolean>;
         autoClosingBrackets: IEditorOption<EditorOption.autoClosingBrackets, 'always' | 'languageDefined' | 'beforeWhitespace' | 'never'>;
         autoClosingDelete: IEditorOption<EditorOption.autoClosingDelete, 'always' | 'never' | 'auto'>;
         autoClosingOvertype: IEditorOption<EditorOption.autoClosingOvertype, 'always' | 'never' | 'auto'>;
@@ -4356,12 +4884,13 @@ declare namespace monaco.editor {
         codeLensFontFamily: IEditorOption<EditorOption.codeLensFontFamily, string>;
         codeLensFontSize: IEditorOption<EditorOption.codeLensFontSize, number>;
         colorDecorators: IEditorOption<EditorOption.colorDecorators, boolean>;
+        colorDecoratorsLimit: IEditorOption<EditorOption.colorDecoratorsLimit, number>;
         columnSelection: IEditorOption<EditorOption.columnSelection, boolean>;
         comments: IEditorOption<EditorOption.comments, Readonly<Required<IEditorCommentsOptions>>>;
         contextmenu: IEditorOption<EditorOption.contextmenu, boolean>;
         copyWithSyntaxHighlighting: IEditorOption<EditorOption.copyWithSyntaxHighlighting, boolean>;
         cursorBlinking: IEditorOption<EditorOption.cursorBlinking, TextEditorCursorBlinkingStyle>;
-        cursorSmoothCaretAnimation: IEditorOption<EditorOption.cursorSmoothCaretAnimation, boolean>;
+        cursorSmoothCaretAnimation: IEditorOption<EditorOption.cursorSmoothCaretAnimation, 'on' | 'off' | 'explicit'>;
         cursorStyle: IEditorOption<EditorOption.cursorStyle, TextEditorCursorStyle>;
         cursorSurroundingLines: IEditorOption<EditorOption.cursorSurroundingLines, number>;
         cursorSurroundingLinesStyle: IEditorOption<EditorOption.cursorSurroundingLinesStyle, 'default' | 'all'>;
@@ -4371,6 +4900,9 @@ declare namespace monaco.editor {
         domReadOnly: IEditorOption<EditorOption.domReadOnly, boolean>;
         dragAndDrop: IEditorOption<EditorOption.dragAndDrop, boolean>;
         emptySelectionClipboard: IEditorOption<EditorOption.emptySelectionClipboard, boolean>;
+        dropIntoEditor: IEditorOption<EditorOption.dropIntoEditor, Readonly<Required<IDropIntoEditorOptions>>>;
+        stickyScroll: IEditorOption<EditorOption.stickyScroll, Readonly<Required<IEditorStickyScrollOptions>>>;
+        experimentalWhitespaceRendering: IEditorOption<EditorOption.experimentalWhitespaceRendering, 'off' | 'svg' | 'font'>;
         extraEditorClassName: IEditorOption<EditorOption.extraEditorClassName, string>;
         fastScrollSensitivity: IEditorOption<EditorOption.fastScrollSensitivity, number>;
         find: IEditorOption<EditorOption.find, Readonly<Required<IEditorFindOptions>>>;
@@ -4386,6 +4918,7 @@ declare namespace monaco.editor {
         fontLigatures2: IEditorOption<EditorOption.fontLigatures, string>;
         fontSize: IEditorOption<EditorOption.fontSize, number>;
         fontWeight: IEditorOption<EditorOption.fontWeight, string>;
+        fontVariations: IEditorOption<EditorOption.fontVariations, string>;
         formatOnPaste: IEditorOption<EditorOption.formatOnPaste, boolean>;
         formatOnType: IEditorOption<EditorOption.formatOnType, boolean>;
         glyphMargin: IEditorOption<EditorOption.glyphMargin, boolean>;
@@ -4395,7 +4928,7 @@ declare namespace monaco.editor {
         inDiffEditor: IEditorOption<EditorOption.inDiffEditor, boolean>;
         letterSpacing: IEditorOption<EditorOption.letterSpacing, number>;
         lightbulb: IEditorOption<EditorOption.lightbulb, Readonly<Required<IEditorLightbulbOptions>>>;
-        lineDecorationsWidth: IEditorOption<EditorOption.lineDecorationsWidth, string | number>;
+        lineDecorationsWidth: IEditorOption<EditorOption.lineDecorationsWidth, number>;
         lineHeight: IEditorOption<EditorOption.lineHeight, number>;
         lineNumbers: IEditorOption<EditorOption.lineNumbers, InternalEditorRenderLineNumbersOptions>;
         lineNumbersMinChars: IEditorOption<EditorOption.lineNumbersMinChars, number>;
@@ -4409,6 +4942,7 @@ declare namespace monaco.editor {
         multiCursorMergeOverlapping: IEditorOption<EditorOption.multiCursorMergeOverlapping, boolean>;
         multiCursorModifier: IEditorOption<EditorOption.multiCursorModifier, 'altKey' | 'metaKey' | 'ctrlKey'>;
         multiCursorPaste: IEditorOption<EditorOption.multiCursorPaste, 'spread' | 'full'>;
+        multiCursorLimit: IEditorOption<EditorOption.multiCursorLimit, number>;
         occurrencesHighlight: IEditorOption<EditorOption.occurrencesHighlight, boolean>;
         overviewRulerBorder: IEditorOption<EditorOption.overviewRulerBorder, boolean>;
         overviewRulerLanes: IEditorOption<EditorOption.overviewRulerLanes, number>;
@@ -4416,12 +4950,12 @@ declare namespace monaco.editor {
         parameterHints: IEditorOption<EditorOption.parameterHints, Readonly<Required<IEditorParameterHintOptions>>>;
         peekWidgetDefaultFocus: IEditorOption<EditorOption.peekWidgetDefaultFocus, 'tree' | 'editor'>;
         definitionLinkOpensInPeek: IEditorOption<EditorOption.definitionLinkOpensInPeek, boolean>;
-        quickSuggestions: IEditorOption<EditorOption.quickSuggestions, any>;
+        quickSuggestions: IEditorOption<EditorOption.quickSuggestions, InternalQuickSuggestionsOptions>;
         quickSuggestionsDelay: IEditorOption<EditorOption.quickSuggestionsDelay, number>;
         readOnly: IEditorOption<EditorOption.readOnly, boolean>;
         renameOnType: IEditorOption<EditorOption.renameOnType, boolean>;
         renderControlCharacters: IEditorOption<EditorOption.renderControlCharacters, boolean>;
-        renderFinalNewline: IEditorOption<EditorOption.renderFinalNewline, boolean>;
+        renderFinalNewline: IEditorOption<EditorOption.renderFinalNewline, 'on' | 'off' | 'dimmed'>;
         renderLineHighlight: IEditorOption<EditorOption.renderLineHighlight, 'all' | 'line' | 'none' | 'gutter'>;
         renderLineHighlightOnlyWhenFocus: IEditorOption<EditorOption.renderLineHighlightOnlyWhenFocus, boolean>;
         renderValidationDecorations: IEditorOption<EditorOption.renderValidationDecorations, 'on' | 'off' | 'editable'>;
@@ -4436,7 +4970,7 @@ declare namespace monaco.editor {
         selectionClipboard: IEditorOption<EditorOption.selectionClipboard, boolean>;
         selectionHighlight: IEditorOption<EditorOption.selectionHighlight, boolean>;
         selectOnLineNumbers: IEditorOption<EditorOption.selectOnLineNumbers, boolean>;
-        showFoldingControls: IEditorOption<EditorOption.showFoldingControls, 'always' | 'mouseover'>;
+        showFoldingControls: IEditorOption<EditorOption.showFoldingControls, 'always' | 'never' | 'mouseover'>;
         showUnused: IEditorOption<EditorOption.showUnused, boolean>;
         showDeprecated: IEditorOption<EditorOption.showDeprecated, boolean>;
         inlayHints: IEditorOption<EditorOption.inlayHints, Readonly<Required<IEditorInlayHintsOptions>>>;
@@ -4452,10 +4986,11 @@ declare namespace monaco.editor {
         suggestSelection: IEditorOption<EditorOption.suggestSelection, 'first' | 'recentlyUsed' | 'recentlyUsedByPrefix'>;
         tabCompletion: IEditorOption<EditorOption.tabCompletion, 'on' | 'off' | 'onlySnippets'>;
         tabIndex: IEditorOption<EditorOption.tabIndex, number>;
-        unicodeHighlight: IEditorOption<EditorOption.unicodeHighlighting, Required<Readonly<IUnicodeHighlightOptions>>>;
+        unicodeHighlight: IEditorOption<EditorOption.unicodeHighlighting, any>;
         unusualLineTerminators: IEditorOption<EditorOption.unusualLineTerminators, 'auto' | 'off' | 'prompt'>;
         useShadowDOM: IEditorOption<EditorOption.useShadowDOM, boolean>;
         useTabStops: IEditorOption<EditorOption.useTabStops, boolean>;
+        wordBreak: IEditorOption<EditorOption.wordBreak, 'normal' | 'keepAll'>;
         wordSeparators: IEditorOption<EditorOption.wordSeparators, string>;
         wordWrap: IEditorOption<EditorOption.wordWrap, 'on' | 'off' | 'wordWrapColumn' | 'bounded'>;
         wordWrapBreakAfterCharacters: IEditorOption<EditorOption.wordWrapBreakAfterCharacters, string>;
@@ -4463,13 +4998,14 @@ declare namespace monaco.editor {
         wordWrapColumn: IEditorOption<EditorOption.wordWrapColumn, number>;
         wordWrapOverride1: IEditorOption<EditorOption.wordWrapOverride1, 'on' | 'off' | 'inherit'>;
         wordWrapOverride2: IEditorOption<EditorOption.wordWrapOverride2, 'on' | 'off' | 'inherit'>;
-        wrappingIndent: IEditorOption<EditorOption.wrappingIndent, WrappingIndent>;
-        wrappingStrategy: IEditorOption<EditorOption.wrappingStrategy, 'simple' | 'advanced'>;
         editorClassName: IEditorOption<EditorOption.editorClassName, string>;
+        defaultColorDecorators: IEditorOption<EditorOption.defaultColorDecorators, boolean>;
         pixelRatio: IEditorOption<EditorOption.pixelRatio, number>;
         tabFocusMode: IEditorOption<EditorOption.tabFocusMode, boolean>;
         layoutInfo: IEditorOption<EditorOption.layoutInfo, EditorLayoutInfo>;
         wrappingInfo: IEditorOption<EditorOption.wrappingInfo, EditorWrappingInfo>;
+        wrappingIndent: IEditorOption<EditorOption.wrappingIndent, WrappingIndent>;
+        wrappingStrategy: IEditorOption<EditorOption.wrappingStrategy, 'simple' | 'advanced'>;
     };
 
     type EditorOptionsType = typeof EditorOptions;
@@ -4514,6 +5050,15 @@ declare namespace monaco.editor {
          * If the `afterColumn` has multiple view columns, the affinity specifies which one to use. Defaults to `none`.
         */
         afterColumnAffinity?: PositionAffinity;
+        /**
+         * Render the zone even when its line is hidden.
+         */
+        showInHiddenAreas?: boolean;
+        /**
+         * Tiebreaker that is used when multiple view zones want to be after the same line.
+         * Defaults to `afterColumn` otherwise 10000;
+         */
+        ordinal?: number;
         /**
          * Suppress mouse down events.
          * If set, the editor will attach a mouse down listener to the view zone and .preventDefault on it.
@@ -4600,19 +5145,33 @@ declare namespace monaco.editor {
      */
     export interface IContentWidgetPosition {
         /**
-         * Desired position for the content widget.
-         * `preference` will also affect the placement.
+         * Desired position which serves as an anchor for placing the content widget.
+         * The widget will be placed above, at, or below the specified position, based on the
+         * provided preference. The widget will always touch this position.
+         *
+         * Given sufficient horizontal space, the widget will be placed to the right of the
+         * passed in position. This can be tweaked by providing a `secondaryPosition`.
+         *
+         * @see preference
+         * @see secondaryPosition
          */
         position: IPosition | null;
         /**
-         * Optionally, a range can be provided to further
-         * define the position of the content widget.
+         * Optionally, a secondary position can be provided to further define the placing of
+         * the content widget. The secondary position must have the same line number as the
+         * primary position. If possible, the widget will be placed such that it also touches
+         * the secondary position.
          */
-        range?: IRange | null;
+        secondaryPosition?: IPosition | null;
         /**
          * Placement preference for position, in order of preference.
          */
         preference: ContentWidgetPositionPreference[];
+        /**
+         * Placement preference when multiple view positions refer to the same (model) position.
+         * This plays a role when injected text is involved.
+        */
+        positionAffinity?: PositionAffinity;
     }
 
     /**
@@ -4871,6 +5430,8 @@ declare namespace monaco.editor {
 
     export interface IMouseTargetOutsideEditor extends IBaseMouseTarget {
         readonly type: MouseTargetType.OUTSIDE_EDITOR;
+        readonly outsidePosition: 'above' | 'below' | 'left' | 'right';
+        readonly outsideDistance: number;
     }
 
     /**
@@ -5073,7 +5634,7 @@ declare namespace monaco.editor {
         /**
          * Restores the view state of the editor from a serializable object generated by `saveViewState`.
          */
-        restoreViewState(state: ICodeEditorViewState): void;
+        restoreViewState(state: ICodeEditorViewState | null): void;
         /**
          * Returns true if the text inside this editor or an editor widget has focus.
          */
@@ -5160,12 +5721,16 @@ declare namespace monaco.editor {
          * Change the scroll position of the editor's viewport.
          */
         setScrollPosition(position: INewScrollPosition, scrollType?: ScrollType): void;
+        /**
+         * Check if the editor is currently scrolling towards a different scroll position.
+         */
+        hasPendingScrollAnimation(): boolean;
         /**
          * Get an action that is a contribution to this editor.
          * @id Unique identifier of the contribution.
          * @return The action or null if action not found.
          */
-        getAction(id: string): IEditorAction;
+        getAction(id: string): IEditorAction | null;
         /**
          * Execute a command on the editor.
          * The edits will land on the undo-redo stack, but no "undo stop" will be pushed.
@@ -5205,9 +5770,14 @@ declare namespace monaco.editor {
         getDecorationsInRange(range: Range): IModelDecoration[] | null;
         /**
          * All decorations added through this call will get the ownerId of this editor.
-         * @see {@link ITextModel.deltaDecorations}
+         * @deprecated Use `createDecorationsCollection`
+         * @see createDecorationsCollection
          */
         deltaDecorations(oldDecorations: string[], newDecorations: IModelDeltaDecoration[]): string[];
+        /**
+         * Remove previously added decorations.
+         */
+        removeDecorations(decorationIds: string[]): void;
         /**
          * Get the layout info for the editor.
          */
@@ -5218,13 +5788,21 @@ declare namespace monaco.editor {
          */
         getVisibleRanges(): Range[];
         /**
-         * Get the vertical position (top offset) for the line w.r.t. to the first line.
+         * Get the vertical position (top offset) for the line's top w.r.t. to the first line.
          */
         getTopForLineNumber(lineNumber: number): number;
+        /**
+         * Get the vertical position (top offset) for the line's bottom w.r.t. to the first line.
+         */
+        getBottomForLineNumber(lineNumber: number): number;
         /**
          * Get the vertical position (top offset) for the position w.r.t. to the first line.
          */
         getTopForPosition(lineNumber: number, column: number): number;
+        /**
+         * Write the screen reader content to be the current selection
+         */
+        writeScreenReaderContent(reason: string): void;
         /**
          * Returns the editor's container dom node
          */
@@ -5319,6 +5897,11 @@ declare namespace monaco.editor {
          * @event
          */
         readonly onDidUpdateDiff: IEvent<void>;
+        /**
+         * An event emitted when the diff model is changed (i.e. the diff editor shows new content).
+         * @event
+         */
+        readonly onDidChangeModel: IEvent<void>;
         /**
          * Saves current view state of the editor in a serializable object.
          */
@@ -5326,7 +5909,7 @@ declare namespace monaco.editor {
         /**
          * Restores the view state of the editor from a serializable object generated by `saveViewState`.
          */
-        restoreViewState(state: IDiffEditorViewState): void;
+        restoreViewState(state: IDiffEditorViewState | null): void;
         /**
          * Type the getModel() of IEditor.
          */
@@ -5389,10 +5972,19 @@ declare namespace monaco.editor {
         readonly fontWeight: string;
         readonly fontSize: number;
         readonly fontFeatureSettings: string;
+        readonly fontVariationSettings: string;
         readonly lineHeight: number;
         readonly letterSpacing: number;
     }
 
+    export const EditorZoom: IEditorZoom;
+
+    export interface IEditorZoom {
+        onDidChangeZoomLevel: IEvent<number>;
+        getZoomLevel(): number;
+        setZoomLevel(zoomLevel: number): void;
+    }
+
     //compatibility:
     export type IReadOnlyModel = ITextModel;
     export type IModel = ITextModel;
@@ -5400,7 +5992,6 @@ declare namespace monaco.editor {
 
 declare namespace monaco.languages {
 
-
     export interface IRelativePattern {
         /**
          * A base file path to which this pattern will be matched against relatively.
@@ -5428,6 +6019,10 @@ declare namespace monaco.languages {
          */
         readonly hasAccessToAllModels?: boolean;
         readonly exclusive?: boolean;
+        /**
+         * This provider comes from a builtin extension.
+         */
+        readonly isBuiltin?: boolean;
     }
 
     /**
@@ -5443,11 +6038,18 @@ declare namespace monaco.languages {
     export function getEncodedLanguageId(languageId: string): number;
 
     /**
-     * An event emitted when a language is needed for the first time (e.g. a model has it set).
+     * An event emitted when a language is associated for the first time with a text model.
      * @event
      */
     export function onLanguage(languageId: string, callback: () => void): IDisposable;
 
+    /**
+     * An event emitted when a language is associated for the first time with a text model or
+     * whena language is encountered during the tokenization of another language.
+     * @event
+     */
+    export function onLanguageEncountered(languageId: string, callback: () => void): IDisposable;
+
     /**
      * Set the editing configuration for a language.
      */
@@ -5722,6 +6324,10 @@ declare namespace monaco.languages {
          * Requested kind of actions to return.
          */
         readonly only?: string;
+        /**
+         * The reason why code actions were requested.
+         */
+        readonly trigger: CodeActionTriggerType;
     }
 
     /**
@@ -5752,6 +6358,10 @@ declare namespace monaco.languages {
          * such as `["quickfix.removeLine", "source.fixAll" ...]`.
          */
         readonly providedCodeActionKinds?: readonly string[];
+        readonly documentation?: ReadonlyArray<{
+            readonly kind: string;
+            readonly command: Command;
+        }>;
     }
 
     /**
@@ -6067,6 +6677,7 @@ declare namespace monaco.languages {
     }
 
     export enum CompletionItemInsertTextRule {
+        None = 0,
         /**
          * Adjust whitespace/indentation of multiline insert texts to
          * match the current line indentation.
@@ -6251,11 +6862,13 @@ declare namespace monaco.languages {
         readonly selectedSuggestionInfo: SelectedSuggestionInfo | undefined;
     }
 
-    export interface SelectedSuggestionInfo {
-        range: IRange;
-        text: string;
-        isSnippetText: boolean;
-        completionKind: CompletionItemKind;
+    export class SelectedSuggestionInfo {
+        readonly range: IRange;
+        readonly text: string;
+        readonly completionKind: CompletionItemKind;
+        readonly isSnippetText: boolean;
+        constructor(range: IRange, text: string, completionKind: CompletionItemKind, isSnippetText: boolean);
+        equals(other: SelectedSuggestionInfo): boolean;
     }
 
     export interface InlineCompletion {
@@ -6263,8 +6876,24 @@ declare namespace monaco.languages {
          * The text to insert.
          * If the text contains a line break, the range must end at the end of a line.
          * If existing text should be replaced, the existing text must be a prefix of the text to insert.
+         *
+         * The text can also be a snippet. In that case, a preview with default parameters is shown.
+         * When accepting the suggestion, the full snippet is inserted.
         */
-        readonly text: string;
+        readonly insertText: string | {
+            snippet: string;
+        };
+        /**
+         * A text that is used to decide if this inline completion should be shown.
+         * An inline completion is shown if the text to replace is a subword of the filter text.
+         */
+        readonly filterText?: string;
+        /**
+         * An optional array of additional text edits that are applied when
+         * selecting this completion. Edits must not overlap with the main edit
+         * nor with themselves.
+         */
+        readonly additionalTextEdits?: editor.ISingleEditOperation[];
         /**
          * The range to replace.
          * Must begin and end on the same line.
@@ -6280,14 +6909,28 @@ declare namespace monaco.languages {
 
     export interface InlineCompletions<TItem extends InlineCompletion = InlineCompletion> {
         readonly items: readonly TItem[];
+        /**
+         * A list of commands associated with the inline completions of this list.
+         */
+        readonly commands?: Command[];
+        readonly suppressSuggestions?: boolean | undefined;
+        /**
+         * When set and the user types a suggestion without derivating from it, the inline suggestion is not updated.
+         */
+        readonly enableForwardStability?: boolean | undefined;
     }
 
     export interface InlineCompletionsProvider<T extends InlineCompletions = InlineCompletions> {
         provideInlineCompletions(model: editor.ITextModel, position: Position, context: InlineCompletionContext, token: CancellationToken): ProviderResult<T>;
         /**
          * Will be called when an item is shown.
+         * @param updatedInsertText Is useful to understand bracket completion.
         */
-        handleItemDidShow?(completions: T, item: T['items'][number]): void;
+        handleItemDidShow?(completions: T, item: T['items'][number], updatedInsertText: string): void;
+        /**
+         * Will be called when an item is partially accepted.
+         */
+        handlePartialAccept?(completions: T, item: T['items'][number], acceptedCharacters: number): void;
         /**
          * Will be called when a completions list is no longer in use and can be garbage-collected.
         */
@@ -6304,6 +6947,11 @@ declare namespace monaco.languages {
         disabled?: string;
     }
 
+    export enum CodeActionTriggerType {
+        Invoke = 1,
+        Auto = 2
+    }
+
     export interface CodeActionList extends IDisposable {
         readonly actions: ReadonlyArray<CodeAction>;
     }
@@ -6640,11 +7288,11 @@ declare namespace monaco.languages {
         provideDocumentSymbols(model: editor.ITextModel, token: CancellationToken): ProviderResult<DocumentSymbol[]>;
     }
 
-    export type TextEdit = {
+    export interface TextEdit {
         range: IRange;
         text: string;
         eol?: editor.EndOfLineSequence;
-    };
+    }
 
     /**
      * Interface used to format a model
@@ -6658,6 +7306,10 @@ declare namespace monaco.languages {
          * Prefer spaces over tabs.
          */
         insertSpaces: boolean;
+        /**
+         * The list of multiple ranges to format at once, if the provider supports it.
+         */
+        ranges?: Range[];
     }
 
     /**
@@ -6686,6 +7338,7 @@ declare namespace monaco.languages {
          * of the range to full syntax nodes.
          */
         provideDocumentRangeFormattingEdits(model: editor.ITextModel, range: Range, options: FormattingOptions, token: CancellationToken): ProviderResult<TextEdit[]>;
+        provideDocumentRangesFormattingEdits?(model: editor.ITextModel, ranges: Range[], options: FormattingOptions, token: CancellationToken): ProviderResult<TextEdit[]>;
     }
 
     /**
@@ -6859,6 +7512,12 @@ declare namespace monaco.languages {
          * The value of the kind is 'region'.
          */
         static readonly Region: FoldingRangeKind;
+        /**
+         * Returns a {@link FoldingRangeKind} for the given value.
+         *
+         * @param value of the kind.
+         */
+        static fromValue(value: string): FoldingRangeKind;
         /**
          * Creates a new {@link FoldingRangeKind}.
          *
@@ -6884,22 +7543,24 @@ declare namespace monaco.languages {
         maxSize?: number;
     }
 
-    export interface WorkspaceFileEdit {
-        oldUri?: Uri;
-        newUri?: Uri;
+    export interface IWorkspaceFileEdit {
+        oldResource?: Uri;
+        newResource?: Uri;
         options?: WorkspaceFileEditOptions;
         metadata?: WorkspaceEditMetadata;
     }
 
-    export interface WorkspaceTextEdit {
+    export interface IWorkspaceTextEdit {
         resource: Uri;
-        edit: TextEdit;
-        modelVersionId?: number;
+        textEdit: TextEdit & {
+            insertAsSnippet?: boolean;
+        };
+        versionId: number | undefined;
         metadata?: WorkspaceEditMetadata;
     }
 
     export interface WorkspaceEdit {
-        edits: Array<WorkspaceTextEdit | WorkspaceFileEdit>;
+        edits: Array<IWorkspaceTextEdit | IWorkspaceFileEdit>;
     }
 
     export interface Rejection {
@@ -6955,7 +7616,7 @@ declare namespace monaco.languages {
     export interface InlayHint {
         label: string | InlayHintLabelPart[];
         tooltip?: string | IMarkdownString;
-        command?: Command;
+        textEdits?: TextEdit[];
         position: IPosition;
         kind?: InlayHintKind;
         paddingLeft?: boolean;
@@ -7134,7 +7795,7 @@ declare namespace monaco.languages {
         log?: string;
     }
 
-    export type IMonarchLanguageAction = IShortMonarchLanguageAction | IExpandedMonarchLanguageAction | IShortMonarchLanguageAction[] | IExpandedMonarchLanguageAction[];
+    export type IMonarchLanguageAction = IShortMonarchLanguageAction | IExpandedMonarchLanguageAction | (IShortMonarchLanguageAction | IExpandedMonarchLanguageAction)[];
 
     /**
      * This interface can be shortened as an array, ie. ['{','}','delimiter.curly']
@@ -7190,6 +7851,20 @@ declare namespace monaco.worker {
  *--------------------------------------------------------------------------------------------*/
 
 declare namespace monaco.languages.css {
+    export interface CSSFormatConfiguration {
+        /** separate selectors with newline (e.g. "a,\nbr" or "a, br"): Default: true */
+        newlineBetweenSelectors?: boolean;
+        /** add a new line after every css rule: Default: true */
+        newlineBetweenRules?: boolean;
+        /** ensure space around selector separators:  '>', '+', '~' (e.g. "a>b" -> "a > b"): Default: false */
+        spaceAroundSelectorSeparator?: boolean;
+        /** put braces on the same line as rules (`collapse`), or put braces on own line, Allman / ANSI style (`expand`). Default `collapse` */
+        braceStyle?: 'collapse' | 'expand';
+        /** whether existing line breaks before elements should be preserved. Default: true */
+        preserveNewLines?: boolean;
+        /** maximum number of line breaks to be preserved in one chunk. Default: unlimited */
+        maxPreserveNewLines?: number;
+    }
     export interface Options {
         readonly validate?: boolean;
         readonly lint?: {
@@ -7216,6 +7891,10 @@ declare namespace monaco.languages.css {
          * Configures the CSS data types known by the langauge service.
          */
         readonly data?: CSSDataConfiguration;
+        /**
+         * Settings for the CSS formatter.
+         */
+        readonly format?: CSSFormatConfiguration;
     }
     export interface ModeConfiguration {
         /**
@@ -7262,6 +7941,14 @@ declare namespace monaco.languages.css {
          * Defines whether the built-in selection range provider is enabled.
          */
         readonly selectionRanges?: boolean;
+        /**
+         * Defines whether the built-in document formatting edit provider is enabled.
+         */
+        readonly documentFormattingEdits?: boolean;
+        /**
+         * Defines whether the built-in document formatting range edit provider is enabled.
+         */
+        readonly documentRangeFormattingEdits?: boolean;
     }
     export interface LanguageServiceDefaults {
         readonly languageId: string;
@@ -7379,11 +8066,11 @@ declare namespace monaco.languages.html {
     }
     export interface Options {
         /**
-         * If set, comments are tolerated. If set to false, syntax errors will be emitted for comments.
+         * Settings for the HTML formatter.
          */
         readonly format?: HTMLFormatConfiguration;
         /**
-         * A list of known schemas and/or associations of schemas to file names.
+         * Code completion settings.
          */
         readonly suggest?: CompletionConfiguration;
         /**
@@ -7834,6 +8521,60 @@ declare namespace monaco.languages.typescript {
         writeByteOrderMark: boolean;
         text: string;
     }
+    export interface ModeConfiguration {
+        /**
+         * Defines whether the built-in completionItemProvider is enabled.
+         */
+        readonly completionItems?: boolean;
+        /**
+         * Defines whether the built-in hoverProvider is enabled.
+         */
+        readonly hovers?: boolean;
+        /**
+         * Defines whether the built-in documentSymbolProvider is enabled.
+         */
+        readonly documentSymbols?: boolean;
+        /**
+         * Defines whether the built-in definitions provider is enabled.
+         */
+        readonly definitions?: boolean;
+        /**
+         * Defines whether the built-in references provider is enabled.
+         */
+        readonly references?: boolean;
+        /**
+         * Defines whether the built-in references provider is enabled.
+         */
+        readonly documentHighlights?: boolean;
+        /**
+         * Defines whether the built-in rename provider is enabled.
+         */
+        readonly rename?: boolean;
+        /**
+         * Defines whether the built-in diagnostic provider is enabled.
+         */
+        readonly diagnostics?: boolean;
+        /**
+         * Defines whether the built-in document formatting range edit provider is enabled.
+         */
+        readonly documentRangeFormattingEdits?: boolean;
+        /**
+         * Defines whether the built-in signature help provider is enabled.
+         */
+        readonly signatureHelp?: boolean;
+        /**
+         * Defines whether the built-in onType formatting edit provider is enabled.
+         */
+        readonly onTypeFormattingEdits?: boolean;
+        /**
+         * Defines whether the built-in code actions provider is enabled.
+         */
+        readonly codeActions?: boolean;
+        /**
+         * Defines whether the built-in inlay hints provider is enabled.
+         */
+        readonly inlayHints?: boolean;
+    }
     export interface LanguageServiceDefaults {
         /**
          * Event fired when compiler options or diagnostics options are changed.
@@ -7845,6 +8586,8 @@ declare namespace monaco.languages.typescript {
         readonly onDidExtraLibsChange: IEvent<void>;
         readonly workerOptions: WorkerOptions;
         readonly inlayHintsOptions: InlayHintsOptions;
+        readonly modeConfiguration: ModeConfiguration;
+        setModeConfiguration(modeConfiguration: ModeConfiguration): void;
         /**
          * Get the current extra libs registered with the language service.
          */
@@ -7952,11 +8695,7 @@ declare namespace monaco.languages.typescript {
          * @returns `Promise<typescript.QuickInfo | undefined>`
          */
         getQuickInfoAtPosition(fileName: string, position: number): Promise<any | undefined>;
-        /**
-         * Get other ranges which are related to the item at the given position in the file (often used for highlighting).
-         * @returns `Promise<ReadonlyArray<typescript.ReferenceEntry> | undefined>`
-         */
-        getOccurrencesAtPosition(fileName: string, position: number): Promise<ReadonlyArray<any> | undefined>;
+        getDocumentHighlights(fileName: string, position: number, filesToSearch: string[]): Promise<ReadonlyArray<any> | undefined>;
         /**
          * Get the definition of the item at the given position in the file.
          * @returns `Promise<ReadonlyArray<typescript.DefinitionInfo> | undefined>`
@@ -7969,9 +8708,9 @@ declare namespace monaco.languages.typescript {
         getReferencesAtPosition(fileName: string, position: number): Promise<any[] | undefined>;
         /**
          * Get outline entries for the item at the given position in the file.
-         * @returns `Promise<typescript.NavigationBarItem[]>`
+         * @returns `Promise<typescript.NavigationTree | undefined>`
          */
-        getNavigationBarItems(fileName: string): Promise<any[]>;
+        getNavigationTree(fileName: string): Promise<any | undefined>;
         /**
          * Get changes which should be applied to format the given file.
          * @param options `typescript.FormatCodeOptions`