@ng-util/monaco-editor 15.0.0 → 16.0.1

package/monaco.d.ts

@@ -19,10 +19,45 @@ declare namespace monaco {
     export type Thenable<T> = PromiseLike<T>;
 
     export interface Environment {
+        /**
+         * Define a global `monaco` symbol.
+         * This is true by default in AMD and false by default in ESM.
+         */
         globalAPI?: boolean;
+        /**
+         * The base url where the editor sources are found (which contains the vs folder)
+         */
         baseUrl?: string;
+        /**
+         * A web worker factory.
+         * NOTE: If `getWorker` is defined, `getWorkerUrl` is not invoked.
+         */
         getWorker?(workerId: string, label: string): Promise<Worker> | Worker;
+        /**
+         * Return the location for web worker scripts.
+         * NOTE: If `getWorker` is defined, `getWorkerUrl` is not invoked.
+         */
         getWorkerUrl?(workerId: string, label: string): string;
+        /**
+         * Create a trusted types policy (same API as window.trustedTypes.createPolicy)
+         */
+        createTrustedTypesPolicy?(
+            policyName: string,
+            policyOptions?: ITrustedTypePolicyOptions,
+        ): undefined | ITrustedTypePolicy;
+    }
+
+    export interface ITrustedTypePolicyOptions {
+        createHTML?: (input: string, ...arguments: any[]) => string;
+        createScript?: (input: string, ...arguments: any[]) => string;
+        createScriptURL?: (input: string, ...arguments: any[]) => string;
+    }
+
+    export interface ITrustedTypePolicy {
+        readonly name: string;
+        createHTML?(input: string): any;
+        createScript?(input: string): any;
+        createScriptURL?(input: string): any;
     }
 
     export interface IDisposable {
@@ -179,13 +214,14 @@ declare namespace monaco {
          * @param path A file system path (see `Uri#fsPath`)
          */
         static file(path: string): Uri;
-        static from(components: {
-            scheme: string;
-            authority?: string;
-            path?: string;
-            query?: string;
-            fragment?: string;
-        }): Uri;
+        /**
+         * Creates new Uri from uri components.
+         *
+         * Unless `strict` is `true` the scheme is defaults to be `file`. This function performs
+         * validation and should be used for untrusted uri components retrieved from storage,
+         * user input, command arguments etc
+         */
+        static from(components: UriComponents, strict?: boolean): Uri;
         /**
          * Join a Uri path with path fragments and normalizes the resulting path.
          *
@@ -207,6 +243,16 @@ declare namespace monaco {
          */
         toString(skipEncoding?: boolean): string;
         toJSON(): UriComponents;
+        /**
+         * A helper function to revive URIs.
+         *
+         * **Note** that this function should only be used when receiving Uri#toJSON generated data
+         * and that it doesn't do any validation. Use {@link Uri.from} when received "untrusted"
+         * uri components such as command arguments or data from storage.
+         *
+         * @param data The Uri components or Uri to revive.
+         * @returns The revived Uri or undefined or null.
+         */
         static revive(data: UriComponents | Uri): Uri;
         static revive(data: UriComponents | Uri | undefined): Uri | undefined;
         static revive(data: UriComponents | Uri | null): Uri | null;
@@ -215,10 +261,10 @@ declare namespace monaco {
 
     export interface UriComponents {
         scheme: string;
-        authority: string;
-        path: string;
-        query: string;
-        fragment: string;
+        authority?: string;
+        path?: string;
+        query?: string;
+        fragment?: string;
     }
     /**
      * Virtual Key Codes, the value does not hold any inherent meaning.
@@ -308,116 +354,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,// VK_NUMPAD0, 0x60, Numeric keypad 0 key
+        Numpad1 = 99,// VK_NUMPAD1, 0x61, Numeric keypad 1 key
+        Numpad2 = 100,// VK_NUMPAD2, 0x62, Numeric keypad 2 key
+        Numpad3 = 101,// VK_NUMPAD3, 0x63, Numeric keypad 3 key
+        Numpad4 = 102,// VK_NUMPAD4, 0x64, Numeric keypad 4 key
+        Numpad5 = 103,// VK_NUMPAD5, 0x65, Numeric keypad 5 key
+        Numpad6 = 104,// VK_NUMPAD6, 0x66, Numeric keypad 6 key
+        Numpad7 = 105,// VK_NUMPAD7, 0x67, Numeric keypad 7 key
+        Numpad8 = 106,// VK_NUMPAD8, 0x68, Numeric keypad 8 key
+        Numpad9 = 107,// VK_NUMPAD9, 0x69, Numeric keypad 9 key
+        NumpadMultiply = 108,// VK_MULTIPLY, 0x6A, Multiply key
+        NumpadAdd = 109,// VK_ADD, 0x6B, Add key
+        NUMPAD_SEPARATOR = 110,// VK_SEPARATOR, 0x6C, Separator key
+        NumpadSubtract = 111,// VK_SUBTRACT, 0x6D, Subtract key
+        NumpadDecimal = 112,// VK_DECIMAL, 0x6E, Decimal key
+        NumpadDivide = 113,// VK_DIVIDE, 0x6F,
         /**
          * 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,// Brazilian (ABNT) Keyboard
+        ABNT_C2 = 116,// Brazilian (ABNT) Keyboard
+        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 +480,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 +489,10 @@ declare namespace monaco {
         };
     }
 
+    export interface MarkdownStringTrustedOptions {
+        readonly enabledCommands: readonly string[];
+    }
+
     export interface IKeyboardEvent {
         readonly _standardKeyboardEventBrand: true;
         readonly browserEvent: KeyboardEvent;
@@ -446,6 +501,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 +724,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 +765,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 +931,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;
     }
@@ -874,13 +942,6 @@ declare namespace monaco {
 
 declare namespace monaco.editor {
 
-    export interface IDiffNavigator {
-        canNavigate(): boolean;
-        next(): void;
-        previous(): void;
-        dispose(): void;
-    }
-
     /**
      * Create a new editor under `domElement`.
      * `domElement` should be empty (not contain other dom nodes).
@@ -918,14 +979,6 @@ declare namespace monaco.editor {
      */
     export function createDiffEditor(domElement: HTMLElement, options?: IStandaloneDiffEditorConstructionOptions, override?: IEditorOverrideServices): IStandaloneDiffEditor;
 
-    export interface IDiffNavigatorOptions {
-        readonly followsCaret?: boolean;
-        readonly ignoreCharChanges?: boolean;
-        readonly alwaysRevealFirst?: boolean;
-    }
-
-    export function createDiffNavigator(diffEditor: IStandaloneDiffEditor, opts?: IDiffNavigatorOptions): IDiffNavigator;
-
     /**
      * Description of a command contribution
      */
@@ -979,7 +1032,7 @@ 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.
@@ -1085,6 +1138,43 @@ declare namespace monaco.editor {
      */
     export function registerCommand(id: string, handler: (accessor: any, ...args: any[]) => void): IDisposable;
 
+    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 {
@@ -1244,7 +1334,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;
@@ -1376,6 +1466,7 @@ declare namespace monaco.editor {
         startColumn: number;
         endLineNumber: number;
         endColumn: number;
+        modelVersionId?: number;
         relatedInformation?: IRelatedInformation[];
         tags?: MarkerTag[];
     }
@@ -1395,6 +1486,7 @@ declare namespace monaco.editor {
         startColumn: number;
         endLineNumber: number;
         endColumn: number;
+        modelVersionId?: number;
         relatedInformation?: IRelatedInformation[];
         tags?: MarkerTag[];
     }
@@ -1478,6 +1570,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.
      */
@@ -1499,6 +1599,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.
      */
@@ -1510,11 +1617,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;
     }
@@ -1532,7 +1639,18 @@ declare namespace monaco.editor {
          * CSS class name describing the decoration.
          */
         className?: string | null;
+        /**
+         * Indicates whether the decoration should span across the entire line when it continues onto the next line.
+         */
+        shouldFillLineOnLineBreak?: boolean | 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.
          */
@@ -1567,6 +1685,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.
          */
@@ -1759,6 +1882,7 @@ declare namespace monaco.editor {
         readonly defaultEOL: DefaultEndOfLine;
         readonly trimAutoWhitespace: boolean;
         readonly bracketPairColorizationOptions: BracketPairColorizationOptions;
+        get originalIndentSize(): number | 'tabSize';
     }
 
     export interface BracketPairColorizationOptions {
@@ -1768,7 +1892,7 @@ declare namespace monaco.editor {
 
     export interface ITextModelUpdateOptions {
         tabSize?: number;
-        indentSize?: number;
+        indentSize?: number | 'tabSize';
         insertSpaces?: boolean;
         trimAutoWhitespace?: boolean;
         bracketColorizationOptions?: BracketPairColorizationOptions;
@@ -1861,12 +1985,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.
          */
@@ -2061,15 +2185,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.
@@ -2308,6 +2439,11 @@ declare namespace monaco.editor {
         modified: ITextModel;
     }
 
+    export interface IDiffEditorViewModel {
+        readonly model: IDiffEditorModel;
+        waitForDiff(): Promise<void>;
+    }
+
     /**
      * An event describing that an editor has had its model reset (i.e. `editor.setModel()`).
      */
@@ -2339,10 +2475,10 @@ 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;
+    export type IEditorModel = ITextModel | IDiffEditorModel | IDiffEditorViewModel;
 
     /**
      * A (serializable) state of the cursors.
@@ -2383,6 +2519,7 @@ declare namespace monaco.editor {
     export interface IDiffEditorViewState {
         original: ICodeEditorViewState | null;
         modified: ICodeEditorViewState | null;
+        modelState?: unknown;
     }
 
     /**
@@ -2634,7 +2771,7 @@ declare namespace monaco.editor {
         /**
          * Replace all previous decorations with `newDecorations`.
          */
-        set(newDecorations: IModelDeltaDecoration[]): void;
+        set(newDecorations: readonly IModelDeltaDecoration[]): string[];
         /**
          * Remove all previous decorations.
          */
@@ -2679,6 +2816,10 @@ declare namespace monaco.editor {
          * New language
          */
         readonly newLanguage: string;
+        /**
+         * Source of the call that caused the event.
+         */
+        readonly source: string;
     }
 
     /**
@@ -2732,6 +2873,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;
     }
 
     /**
@@ -2740,6 +2885,7 @@ declare namespace monaco.editor {
     export interface IModelDecorationsChangedEvent {
         readonly affectsMinimap: boolean;
         readonly affectsOverviewRuler: boolean;
+        readonly affectsGlyphMargin: boolean;
     }
 
     export interface IModelOptionsChangedEvent {
@@ -2886,6 +3032,14 @@ declare namespace monaco.editor {
          * The aria label for the editor's textarea (when it is focused).
          */
         ariaLabel?: string;
+        /**
+         * Whether the aria-required attribute should be set on the editors textarea.
+         */
+        ariaRequired?: boolean;
+        /**
+         * Control whether a screen reader announces inline suggestion content immediately.
+         */
+        screenReaderAnnounceInlineSuggestion?: boolean;
         /**
          * The `tabindex` property of the editor's textarea
          */
@@ -2926,9 +3080,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'.
@@ -2976,6 +3130,10 @@ declare namespace monaco.editor {
          * Defaults to false.
          */
         readOnly?: boolean;
+        /**
+         * The message to display when the editor is readonly.
+         */
+        readOnlyMessage?: IMarkdownString;
         /**
          * Should the textarea used for input use the DOM `readonly` attribute.
          * Defaults to false.
@@ -3000,9 +3158,9 @@ declare namespace monaco.editor {
          */
         scrollbar?: IEditorScrollbarOptions;
         /**
-         * Control the behavior of experimental options
+         * Control the behavior of sticky scroll options
          */
-        experimental?: IEditorExperimentalOptions;
+        stickyScroll?: IEditorStickyScrollOptions;
         /**
          * Control the behavior and rendering of the minimap.
          */
@@ -3043,9 +3201,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'.
@@ -3060,6 +3218,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.
@@ -3092,8 +3259,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;
@@ -3141,6 +3307,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.
@@ -3160,6 +3332,14 @@ declare namespace monaco.editor {
          * Enable inline color decorators and color picker rendering.
          */
         colorDecorators?: boolean;
+        /**
+         * Controls what is the condition to spawn a color picker from a color dectorator
+         */
+        colorDecoratorsActivatedOn?: 'clickAndHover' | 'click' | 'hover';
+        /**
+         * 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.
          */
@@ -3204,6 +3384,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'.
@@ -3249,6 +3433,11 @@ declare namespace monaco.editor {
          * Defaults to language defined behavior.
          */
         autoClosingBrackets?: EditorAutoClosingStrategy;
+        /**
+         * Options for auto closing comments.
+         * Defaults to language defined behavior.
+         */
+        autoClosingComments?: EditorAutoClosingStrategy;
         /**
          * Options for auto closing quotes.
          * Defaults to language defined behavior.
@@ -3408,6 +3597,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'.
@@ -3470,6 +3664,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.
          */
@@ -3497,6 +3695,18 @@ declare namespace monaco.editor {
          * When enabled, this shows a preview of the drop location and triggers an `onDropIntoEditor` event.
          */
         dropIntoEditor?: IDropIntoEditorOptions;
+        /**
+         * Controls support for changing how content is pasted into the editor.
+         */
+        pasteAs?: IPasteAsOptions;
+        /**
+         * Controls whether the editor / terminal receives tabs or defers them to the workbench for navigation.
+         */
+        tabFocusMode?: boolean;
+        /**
+         * Controls whether the accessibility hint should be provided to screen reader users when an inline completion is shown.
+         */
+        inlineCompletionsAccessibilityVerbose?: boolean;
     }
 
     export interface IDiffEditorBaseOptions {
@@ -3505,11 +3715,27 @@ 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.
          */
         renderSideBySide?: boolean;
+        /**
+         * When `renderSideBySide` is enabled, `useInlineViewWhenSpaceIsLimited` is set,
+         * and the diff editor has a width less than `renderSideBySideInlineBreakpoint`, the inline view is used.
+         */
+        renderSideBySideInlineBreakpoint?: number | undefined;
+        /**
+         * When `renderSideBySide` is enabled, `useInlineViewWhenSpaceIsLimited` is set,
+         * and the diff editor has a width less than `renderSideBySideInlineBreakpoint`, the inline view is used.
+         */
+        useInlineViewWhenSpaceIsLimited?: boolean;
         /**
          * Timeout in milliseconds after which diff computation is cancelled.
          * Defaults to 5000.
@@ -3554,6 +3780,36 @@ declare namespace monaco.editor {
          * Control the wrapping of the diff editor.
          */
         diffWordWrap?: 'off' | 'on' | 'inherit';
+        /**
+         * Diff Algorithm
+        */
+        diffAlgorithm?: 'legacy' | 'advanced';
+        /**
+         * Whether the diff editor aria label should be verbose.
+         */
+        accessibilityVerbose?: boolean;
+        experimental?: {
+            /**
+             * Defaults to false.
+             */
+            showMoves?: boolean;
+            showEmptyDecorations?: boolean;
+        };
+        /**
+         * Is the diff editor inside another editor
+         * Defaults to false
+         */
+        isInEmbeddedEditor?: boolean;
+        /**
+         * If the diff editor should only show the difference review mode.
+         */
+        onlyShowAccessibleDiffViewer?: boolean;
+        hideUnchangedRegions?: {
+            enabled?: boolean;
+            revealLineCount?: number;
+            minimumLineCount?: number;
+            contextLineCount?: number;
+        };
     }
 
     /**
@@ -3686,7 +3942,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;
     }
@@ -3729,6 +3985,11 @@ declare namespace monaco.editor {
          * Defaults to true.
          */
         sticky?: boolean;
+        /**
+         * Controls how long the hover is visible after you hovered out of it.
+         * Require sticky setting to be true.
+         */
+        hidingDelay?: number;
         /**
          * Should the hover be shown above the line if possible?
          * Defaults to false.
@@ -3784,6 +4045,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.
          */
@@ -3861,22 +4126,23 @@ declare namespace monaco.editor {
         enabled?: boolean;
     }
 
-    export interface IEditorExperimentalOptions {
+    export interface IEditorStickyScrollOptions {
         /**
-         * Configuration options for editor sticky scroll
+         * Enable the sticky scroll
          */
-        stickyScroll?: {
-            /**
-             * Enable the sticky scroll
-             */
-            enabled?: boolean;
-        };
-    }
-
-    export interface EditorExperimentalOptions {
-        stickyScroll: {
-            enabled: boolean;
-        };
+        enabled?: boolean;
+        /**
+         * Maximum number of sticky lines to show
+         */
+        maxLineCount?: number;
+        /**
+         * Model to choose for sticky scroll by default
+         */
+        defaultModel?: 'outlineModel' | 'foldingProviderModel' | 'indentationModel';
+        /**
+         * Define whether to scroll sticky scroll with editor horizontal scrollbae
+         */
+        scrollWithEditor?: boolean;
     }
 
     /**
@@ -4159,6 +4425,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 {
@@ -4224,6 +4496,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.
          */
@@ -4260,6 +4536,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.
          */
@@ -4360,6 +4640,7 @@ declare namespace monaco.editor {
 
     export interface ISmartSelectOptions {
         selectLeadingAndTrailingWhitespace?: boolean;
+        selectSubwords?: boolean;
     }
 
     /**
@@ -4396,10 +4677,31 @@ declare namespace monaco.editor {
      */
     export interface IDropIntoEditorOptions {
         /**
-         * Enable the dropping into editor.
+         * Enable dropping into editor.
          * Defaults to true.
          */
         enabled?: boolean;
+        /**
+         * Controls if a widget is shown after a drop.
+         * Defaults to 'afterDrop'.
+         */
+        showDropSelector?: 'afterDrop' | 'never';
+    }
+
+    /**
+     * Configuration options for editor pasting as into behavior
+     */
+    export interface IPasteAsOptions {
+        /**
+         * Enable paste as functionality in editors.
+         * Defaults to true.
+         */
+        enabled?: boolean;
+        /**
+         * Controls if a widget is shown after a drop.
+         * Defaults to 'afterPaste'.
+         */
+        showPasteSelector?: 'afterPaste' | 'never';
     }
 
     export enum EditorOption {
@@ -4408,136 +4710,149 @@ declare namespace monaco.editor {
         accessibilitySupport = 2,
         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,
-        dropIntoEditor = 32,
-        emptySelectionClipboard = 33,
-        experimental = 34,
-        extraEditorClassName = 35,
-        fastScrollSensitivity = 36,
-        find = 37,
-        fixedOverflowWidgets = 38,
-        folding = 39,
-        foldingStrategy = 40,
-        foldingHighlight = 41,
-        foldingImportsByDefault = 42,
-        foldingMaximumRegions = 43,
-        unfoldOnClickAfterEndOfLine = 44,
-        fontFamily = 45,
-        fontInfo = 46,
-        fontLigatures = 47,
-        fontSize = 48,
-        fontWeight = 49,
-        formatOnPaste = 50,
-        formatOnType = 51,
-        glyphMargin = 52,
-        gotoLocation = 53,
-        hideCursorInOverviewRuler = 54,
-        hover = 55,
-        inDiffEditor = 56,
-        inlineSuggest = 57,
-        letterSpacing = 58,
-        lightbulb = 59,
-        lineDecorationsWidth = 60,
-        lineHeight = 61,
-        lineNumbers = 62,
-        lineNumbersMinChars = 63,
-        linkedEditing = 64,
-        links = 65,
-        matchBrackets = 66,
-        minimap = 67,
-        mouseStyle = 68,
-        mouseWheelScrollSensitivity = 69,
-        mouseWheelZoom = 70,
-        multiCursorMergeOverlapping = 71,
-        multiCursorModifier = 72,
-        multiCursorPaste = 73,
-        occurrencesHighlight = 74,
-        overviewRulerBorder = 75,
-        overviewRulerLanes = 76,
-        padding = 77,
-        parameterHints = 78,
-        peekWidgetDefaultFocus = 79,
-        definitionLinkOpensInPeek = 80,
-        quickSuggestions = 81,
-        quickSuggestionsDelay = 82,
-        readOnly = 83,
-        renameOnType = 84,
-        renderControlCharacters = 85,
-        renderFinalNewline = 86,
-        renderLineHighlight = 87,
-        renderLineHighlightOnlyWhenFocus = 88,
-        renderValidationDecorations = 89,
-        renderWhitespace = 90,
-        revealHorizontalRightPadding = 91,
-        roundedSelection = 92,
-        rulers = 93,
-        scrollbar = 94,
-        scrollBeyondLastColumn = 95,
-        scrollBeyondLastLine = 96,
-        scrollPredominantAxis = 97,
-        selectionClipboard = 98,
-        selectionHighlight = 99,
-        selectOnLineNumbers = 100,
-        showFoldingControls = 101,
-        showUnused = 102,
-        snippetSuggestions = 103,
-        smartSelect = 104,
-        smoothScrolling = 105,
-        stickyTabStops = 106,
-        stopRenderingLineAfter = 107,
-        suggest = 108,
-        suggestFontSize = 109,
-        suggestLineHeight = 110,
-        suggestOnTriggerCharacters = 111,
-        suggestSelection = 112,
-        tabCompletion = 113,
-        tabIndex = 114,
-        unicodeHighlighting = 115,
-        unusualLineTerminators = 116,
-        useShadowDOM = 117,
-        useTabStops = 118,
-        wordSeparators = 119,
-        wordWrap = 120,
-        wordWrapBreakAfterCharacters = 121,
-        wordWrapBreakBeforeCharacters = 122,
-        wordWrapColumn = 123,
-        wordWrapOverride1 = 124,
-        wordWrapOverride2 = 125,
-        wrappingIndent = 126,
-        wrappingStrategy = 127,
-        showDeprecated = 128,
-        inlayHints = 129,
-        editorClassName = 130,
-        pixelRatio = 131,
-        tabFocusMode = 132,
-        layoutInfo = 133,
-        wrappingInfo = 134
+        ariaRequired = 5,
+        autoClosingBrackets = 6,
+        autoClosingComments = 7,
+        screenReaderAnnounceInlineSuggestion = 8,
+        autoClosingDelete = 9,
+        autoClosingOvertype = 10,
+        autoClosingQuotes = 11,
+        autoIndent = 12,
+        automaticLayout = 13,
+        autoSurround = 14,
+        bracketPairColorization = 15,
+        guides = 16,
+        codeLens = 17,
+        codeLensFontFamily = 18,
+        codeLensFontSize = 19,
+        colorDecorators = 20,
+        colorDecoratorsLimit = 21,
+        columnSelection = 22,
+        comments = 23,
+        contextmenu = 24,
+        copyWithSyntaxHighlighting = 25,
+        cursorBlinking = 26,
+        cursorSmoothCaretAnimation = 27,
+        cursorStyle = 28,
+        cursorSurroundingLines = 29,
+        cursorSurroundingLinesStyle = 30,
+        cursorWidth = 31,
+        disableLayerHinting = 32,
+        disableMonospaceOptimizations = 33,
+        domReadOnly = 34,
+        dragAndDrop = 35,
+        dropIntoEditor = 36,
+        emptySelectionClipboard = 37,
+        experimentalWhitespaceRendering = 38,
+        extraEditorClassName = 39,
+        fastScrollSensitivity = 40,
+        find = 41,
+        fixedOverflowWidgets = 42,
+        folding = 43,
+        foldingStrategy = 44,
+        foldingHighlight = 45,
+        foldingImportsByDefault = 46,
+        foldingMaximumRegions = 47,
+        unfoldOnClickAfterEndOfLine = 48,
+        fontFamily = 49,
+        fontInfo = 50,
+        fontLigatures = 51,
+        fontSize = 52,
+        fontWeight = 53,
+        fontVariations = 54,
+        formatOnPaste = 55,
+        formatOnType = 56,
+        glyphMargin = 57,
+        gotoLocation = 58,
+        hideCursorInOverviewRuler = 59,
+        hover = 60,
+        inDiffEditor = 61,
+        inlineSuggest = 62,
+        letterSpacing = 63,
+        lightbulb = 64,
+        lineDecorationsWidth = 65,
+        lineHeight = 66,
+        lineNumbers = 67,
+        lineNumbersMinChars = 68,
+        linkedEditing = 69,
+        links = 70,
+        matchBrackets = 71,
+        minimap = 72,
+        mouseStyle = 73,
+        mouseWheelScrollSensitivity = 74,
+        mouseWheelZoom = 75,
+        multiCursorMergeOverlapping = 76,
+        multiCursorModifier = 77,
+        multiCursorPaste = 78,
+        multiCursorLimit = 79,
+        occurrencesHighlight = 80,
+        overviewRulerBorder = 81,
+        overviewRulerLanes = 82,
+        padding = 83,
+        pasteAs = 84,
+        parameterHints = 85,
+        peekWidgetDefaultFocus = 86,
+        definitionLinkOpensInPeek = 87,
+        quickSuggestions = 88,
+        quickSuggestionsDelay = 89,
+        readOnly = 90,
+        readOnlyMessage = 91,
+        renameOnType = 92,
+        renderControlCharacters = 93,
+        renderFinalNewline = 94,
+        renderLineHighlight = 95,
+        renderLineHighlightOnlyWhenFocus = 96,
+        renderValidationDecorations = 97,
+        renderWhitespace = 98,
+        revealHorizontalRightPadding = 99,
+        roundedSelection = 100,
+        rulers = 101,
+        scrollbar = 102,
+        scrollBeyondLastColumn = 103,
+        scrollBeyondLastLine = 104,
+        scrollPredominantAxis = 105,
+        selectionClipboard = 106,
+        selectionHighlight = 107,
+        selectOnLineNumbers = 108,
+        showFoldingControls = 109,
+        showUnused = 110,
+        snippetSuggestions = 111,
+        smartSelect = 112,
+        smoothScrolling = 113,
+        stickyScroll = 114,
+        stickyTabStops = 115,
+        stopRenderingLineAfter = 116,
+        suggest = 117,
+        suggestFontSize = 118,
+        suggestLineHeight = 119,
+        suggestOnTriggerCharacters = 120,
+        suggestSelection = 121,
+        tabCompletion = 122,
+        tabIndex = 123,
+        unicodeHighlighting = 124,
+        unusualLineTerminators = 125,
+        useShadowDOM = 126,
+        useTabStops = 127,
+        wordBreak = 128,
+        wordSeparators = 129,
+        wordWrap = 130,
+        wordWrapBreakAfterCharacters = 131,
+        wordWrapBreakBeforeCharacters = 132,
+        wordWrapColumn = 133,
+        wordWrapOverride1 = 134,
+        wordWrapOverride2 = 135,
+        wrappingIndent = 136,
+        wrappingStrategy = 137,
+        showDeprecated = 138,
+        inlayHints = 139,
+        editorClassName = 140,
+        pixelRatio = 141,
+        tabFocusMode = 142,
+        layoutInfo = 143,
+        wrappingInfo = 144,
+        defaultColorDecorators = 145,
+        colorDecoratorsActivatedOn = 146,
+        inlineCompletionsAccessibilityVerbose = 147
     }
 
     export const EditorOptions: {
@@ -4546,7 +4861,10 @@ declare namespace monaco.editor {
         accessibilitySupport: IEditorOption<EditorOption.accessibilitySupport, AccessibilitySupport>;
         accessibilityPageSize: IEditorOption<EditorOption.accessibilityPageSize, number>;
         ariaLabel: IEditorOption<EditorOption.ariaLabel, string>;
+        ariaRequired: IEditorOption<EditorOption.ariaRequired, boolean>;
+        screenReaderAnnounceInlineSuggestion: IEditorOption<EditorOption.screenReaderAnnounceInlineSuggestion, boolean>;
         autoClosingBrackets: IEditorOption<EditorOption.autoClosingBrackets, 'always' | 'languageDefined' | 'beforeWhitespace' | 'never'>;
+        autoClosingComments: IEditorOption<EditorOption.autoClosingComments, 'always' | 'languageDefined' | 'beforeWhitespace' | 'never'>;
         autoClosingDelete: IEditorOption<EditorOption.autoClosingDelete, 'always' | 'never' | 'auto'>;
         autoClosingOvertype: IEditorOption<EditorOption.autoClosingOvertype, 'always' | 'never' | 'auto'>;
         autoClosingQuotes: IEditorOption<EditorOption.autoClosingQuotes, 'always' | 'languageDefined' | 'beforeWhitespace' | 'never'>;
@@ -4560,12 +4878,14 @@ declare namespace monaco.editor {
         codeLensFontFamily: IEditorOption<EditorOption.codeLensFontFamily, string>;
         codeLensFontSize: IEditorOption<EditorOption.codeLensFontSize, number>;
         colorDecorators: IEditorOption<EditorOption.colorDecorators, boolean>;
+        colorDecoratorActivatedOn: IEditorOption<EditorOption.colorDecoratorsActivatedOn, 'clickAndHover' | 'click' | 'hover'>;
+        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'>;
@@ -4576,7 +4896,8 @@ declare namespace monaco.editor {
         dragAndDrop: IEditorOption<EditorOption.dragAndDrop, boolean>;
         emptySelectionClipboard: IEditorOption<EditorOption.emptySelectionClipboard, boolean>;
         dropIntoEditor: IEditorOption<EditorOption.dropIntoEditor, Readonly<Required<IDropIntoEditorOptions>>>;
-        experimental: IEditorOption<EditorOption.experimental, EditorExperimentalOptions>;
+        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>>>;
@@ -4592,6 +4913,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>;
@@ -4601,7 +4923,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>;
@@ -4615,19 +4937,22 @@ 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>;
         padding: IEditorOption<EditorOption.padding, Readonly<Required<IEditorPaddingOptions>>>;
+        pasteAs: IEditorOption<EditorOption.pasteAs, Readonly<Required<IPasteAsOptions>>>;
         parameterHints: IEditorOption<EditorOption.parameterHints, Readonly<Required<IEditorParameterHintOptions>>>;
         peekWidgetDefaultFocus: IEditorOption<EditorOption.peekWidgetDefaultFocus, 'tree' | 'editor'>;
         definitionLinkOpensInPeek: IEditorOption<EditorOption.definitionLinkOpensInPeek, boolean>;
         quickSuggestions: IEditorOption<EditorOption.quickSuggestions, InternalQuickSuggestionsOptions>;
         quickSuggestionsDelay: IEditorOption<EditorOption.quickSuggestionsDelay, number>;
         readOnly: IEditorOption<EditorOption.readOnly, boolean>;
+        readOnlyMessage: IEditorOption<EditorOption.readOnlyMessage, any>;
         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'>;
@@ -4652,6 +4977,7 @@ declare namespace monaco.editor {
         stopRenderingLineAfter: IEditorOption<EditorOption.stopRenderingLineAfter, number>;
         suggest: IEditorOption<EditorOption.suggest, Readonly<Required<ISuggestOptions>>>;
         inlineSuggest: IEditorOption<EditorOption.inlineSuggest, Readonly<Required<IInlineSuggestOptions>>>;
+        inlineCompletionsAccessibilityVerbose: IEditorOption<EditorOption.inlineCompletionsAccessibilityVerbose, boolean>;
         suggestFontSize: IEditorOption<EditorOption.suggestFontSize, number>;
         suggestLineHeight: IEditorOption<EditorOption.suggestLineHeight, number>;
         suggestOnTriggerCharacters: IEditorOption<EditorOption.suggestOnTriggerCharacters, boolean>;
@@ -4662,6 +4988,7 @@ declare namespace monaco.editor {
         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>;
@@ -4669,13 +4996,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;
@@ -4720,6 +5048,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.
@@ -4806,15 +5143,24 @@ 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.
          */
@@ -4910,6 +5256,47 @@ declare namespace monaco.editor {
          * If null is returned, the overlay widget is responsible to place itself.
          */
         getPosition(): IOverlayWidgetPosition | null;
+        /**
+         * The editor will ensure that the scroll width is >= than this value.
+         */
+        getMinContentWidthInPx?(): number;
+    }
+
+    /**
+     * A glyph margin widget renders in the editor glyph margin.
+     */
+    export interface IGlyphMarginWidget {
+        /**
+         * Get a unique identifier of the glyph widget.
+         */
+        getId(): string;
+        /**
+         * Get the dom node of the glyph widget.
+         */
+        getDomNode(): HTMLElement;
+        /**
+         * Get the placement of the glyph widget.
+         */
+        getPosition(): IGlyphMarginWidgetPosition;
+    }
+
+    /**
+     * A position for rendering glyph margin widgets.
+     */
+    export interface IGlyphMarginWidgetPosition {
+        /**
+         * The glyph margin lane where the widget should be shown.
+         */
+        lane: GlyphMarginLane;
+        /**
+         * The priority order of the widget, used for determining which widget
+         * to render when there are multiple.
+         */
+        zIndex: number;
+        /**
+         * The editor range that this widget applies to.
+         */
+        range: IRange;
     }
 
     /**
@@ -4978,7 +5365,7 @@ declare namespace monaco.editor {
         /**
          * The target element
          */
-        readonly element: Element | null;
+        readonly element: HTMLElement | null;
         /**
          * The 'approximate' editor position
          */
@@ -5082,6 +5469,8 @@ declare namespace monaco.editor {
 
     export interface IMouseTargetOutsideEditor extends IBaseMouseTarget {
         readonly type: MouseTargetType.OUTSIDE_EDITOR;
+        readonly outsidePosition: 'above' | 'below' | 'left' | 'right';
+        readonly outsideDistance: number;
     }
 
     /**
@@ -5110,11 +5499,7 @@ declare namespace monaco.editor {
         readonly languageId: string | null;
     }
 
-    export interface IDiffEditorConstructionOptions extends IDiffEditorOptions {
-        /**
-         * The initial editor dimension (to avoid measuring the container).
-         */
-        dimension?: IDimension;
+    export interface IDiffEditorConstructionOptions extends IDiffEditorOptions, IEditorConstructionOptions {
         /**
          * Place overflow widgets inside an external DOM node.
          * Defaults to an internal DOM node.
@@ -5128,11 +5513,6 @@ declare namespace monaco.editor {
          * Aria label for modified editor.
          */
         modifiedAriaLabel?: string;
-        /**
-         * Is the diff editor inside another editor
-         * Defaults to false
-         */
-        isInEmbeddedEditor?: boolean;
     }
 
     /**
@@ -5371,12 +5751,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.
@@ -5416,7 +5800,8 @@ declare namespace monaco.editor {
         getDecorationsInRange(range: Range): IModelDecoration[] | null;
         /**
          * All decorations added through this call will get the ownerId of this editor.
-         * @deprecated
+         * @deprecated Use `createDecorationsCollection`
+         * @see createDecorationsCollection
          */
         deltaDecorations(oldDecorations: string[], newDecorations: IModelDeltaDecoration[]): string[];
         /**
@@ -5435,7 +5820,7 @@ declare namespace monaco.editor {
         /**
          * Get the vertical position (top offset) for the line's top w.r.t. to the first line.
          */
-        getTopForLineNumber(lineNumber: number): number;
+        getTopForLineNumber(lineNumber: number, includeViewZones?: boolean): number;
         /**
          * Get the vertical position (top offset) for the line's bottom w.r.t. to the first line.
          */
@@ -5444,6 +5829,10 @@ declare namespace monaco.editor {
          * 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
          */
@@ -5478,6 +5867,19 @@ declare namespace monaco.editor {
          * Remove an overlay widget.
          */
         removeOverlayWidget(widget: IOverlayWidget): void;
+        /**
+         * Add a glyph margin widget. Widgets must have unique ids, otherwise they will be overwritten.
+         */
+        addGlyphMarginWidget(widget: IGlyphMarginWidget): void;
+        /**
+         * Layout/Reposition a glyph margin widget. This is a ping to the editor to call widget.getPosition()
+         * and update appropriately.
+         */
+        layoutGlyphMarginWidget(widget: IGlyphMarginWidget): void;
+        /**
+         * Remove a glyph margin widget.
+         */
+        removeGlyphMarginWidget(widget: IGlyphMarginWidget): void;
         /**
          * Change the view zones. View zones are lost when a new model is attached to the editor.
          */
@@ -5516,13 +5918,11 @@ declare namespace monaco.editor {
          */
         applyFontInfo(target: HTMLElement): void;
         setBanner(bannerDomNode: HTMLElement | null, height: number): void;
-    }
-
-    /**
-     * Information about a line in the diff editor
-     */
-    export interface IDiffLineInformation {
-        readonly equivalentLineNumber: number;
+        /**
+         * Is called when the model has been set, view state was restored and options are updated.
+         * This is the best place to compute data for the viewport (such as tokens).
+         */
+        handleInitialized?(): void;
     }
 
     /**
@@ -5538,6 +5938,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.
          */
@@ -5550,6 +5955,7 @@ declare namespace monaco.editor {
          * Type the getModel() of IEditor.
          */
         getModel(): IDiffEditorModel | null;
+        createViewModel(model: IDiffEditorModel): IDiffEditorViewModel;
         /**
          * Sets the current model attached to this editor.
          * If the previous model was created by the editor via the value key in the options
@@ -5558,7 +5964,7 @@ declare namespace monaco.editor {
          * 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;
+        setModel(model: IDiffEditorModel | IDiffEditorViewModel | null): void;
         /**
          * Get the `original` editor.
          */
@@ -5571,20 +5977,12 @@ declare namespace monaco.editor {
          * Get the computed diff information.
          */
         getLineChanges(): ILineChange[] | 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;
+        accessibleDiffViewerNext(): void;
+        accessibleDiffViewerPrev(): void;
     }
 
     export class FontInfo extends BareFontInfo {
@@ -5608,10 +6006,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;
@@ -5646,6 +6053,10 @@ declare namespace monaco.languages {
          */
         readonly hasAccessToAllModels?: boolean;
         readonly exclusive?: boolean;
+        /**
+         * This provider comes from a builtin extension.
+         */
+        readonly isBuiltin?: boolean;
     }
 
     /**
@@ -5661,11 +6072,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
+     * when a 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.
      */
@@ -6293,6 +6711,7 @@ declare namespace monaco.languages {
     }
 
     export enum CompletionItemInsertTextRule {
+        None = 0,
         /**
          * Adjust whitespace/indentation of multiline insert texts to
          * match the current line indentation.
@@ -6477,11 +6896,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 {
@@ -6526,18 +6947,41 @@ declare namespace monaco.languages {
          * 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 type InlineCompletionProviderGroupId = string;
+
     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.
         */
         freeInlineCompletions(completions: T): void;
+        /**
+         * Only used for {@link yieldsToGroupIds}.
+         * Multiple providers can have the same group id.
+         */
+        groupId?: InlineCompletionProviderGroupId;
+        /**
+         * Returns a list of preferred provider {@link groupId}s.
+         * The current provider is only requested for completions if no provider with a preferred group id returned a result.
+         */
+        yieldsToGroupIds?: InlineCompletionProviderGroupId[];
+        toString?(): string;
     }
 
     export interface CodeAction {
@@ -6937,6 +7381,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[]>;
     }
 
     /**
@@ -7110,6 +7555,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}.
          *
@@ -7176,6 +7627,13 @@ declare namespace monaco.languages {
         arguments?: any[];
     }
 
+    export interface PendingCommentThread {
+        body: string;
+        range: IRange;
+        uri: Uri;
+        owner: string;
+    }
+
     export interface CodeLens {
         range: IRange;
         id?: string;
@@ -7260,6 +7718,31 @@ declare namespace monaco.languages {
         provideDocumentRangeSemanticTokens(model: editor.ITextModel, range: Range, token: CancellationToken): ProviderResult<SemanticTokens>;
     }
 
+    export interface DocumentContextItem {
+        readonly uri: Uri;
+        readonly version: number;
+        readonly ranges: IRange[];
+    }
+
+    export interface MappedEditsContext {
+        /** The outer array is sorted by priority - from highest to lowest. The inner arrays contain elements of the same priority. */
+        documents: DocumentContextItem[][];
+    }
+
+    export interface MappedEditsProvider {
+        /**
+         * Provider maps code blocks from the chat into a workspace edit.
+         *
+         * @param document The document to provide mapped edits for.
+         * @param codeBlocks Code blocks that come from an LLM's reply.
+         * 						"Insert at cursor" in the panel chat only sends one edit that the user clicks on, but inline chat can send multiple blocks and let the lang server decide what to do with them.
+         * @param context The context for providing mapped edits.
+         * @param token A cancellation token.
+         * @returns A provider result of text edits.
+         */
+        provideMappedEdits(document: editor.ITextModel, codeBlocks: string[], context: MappedEditsContext, token: CancellationToken): Promise<WorkspaceEdit | null>;
+    }
+
     export interface ILanguageExtensionPoint {
         id: string;
         extensions?: string[];
@@ -7387,7 +7870,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']
@@ -8113,6 +8596,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.
@@ -8124,6 +8661,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.
          */
@@ -8231,11 +8770,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>`
@@ -8248,9 +8783,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`