@ng-util/monaco-editor 16.0.0 → 17.0.0-rc.0

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.
@@ -378,28 +424,28 @@ declare namespace monaco {
          * Either the angle bracket key or the backslash key on the RT 102-key keyboard.
          */
         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,
+        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 = 114,
-        ABNT_C1 = 115,
-        ABNT_C2 = 116,
+        ABNT_C1 = 115,// Brazilian (ABNT) Keyboard
+        ABNT_C2 = 116,// Brazilian (ABNT) Keyboard
         AudioVolumeMute = 117,
         AudioVolumeUp = 118,
         AudioVolumeDown = 119,
@@ -896,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).
@@ -940,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
      */
@@ -1608,6 +1639,10 @@ 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.
@@ -2321,144 +2356,6 @@ 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;
@@ -2542,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()`).
      */
@@ -2576,7 +2478,7 @@ declare namespace monaco.editor {
         run(args?: unknown): Promise<void>;
     }
 
-    export type IEditorModel = ITextModel | IDiffEditorModel;
+    export type IEditorModel = ITextModel | IDiffEditorModel | IDiffEditorViewModel;
 
     /**
      * A (serializable) state of the cursors.
@@ -2617,6 +2519,7 @@ declare namespace monaco.editor {
     export interface IDiffEditorViewState {
         original: ICodeEditorViewState | null;
         modified: ICodeEditorViewState | null;
+        modelState?: unknown;
     }
 
     /**
@@ -3129,6 +3032,10 @@ 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.
          */
@@ -3223,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.
@@ -3421,6 +3332,10 @@ 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.
          */
@@ -3518,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.
@@ -3776,9 +3696,17 @@ declare namespace monaco.editor {
          */
         dropIntoEditor?: IDropIntoEditorOptions;
         /**
-         * Controls whether the editor receives tabs or defers them to the workbench for navigation.
+         * 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 {
@@ -3798,6 +3726,16 @@ declare namespace monaco.editor {
          * 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.
@@ -3845,11 +3783,33 @@ declare namespace monaco.editor {
         /**
          * Diff Algorithm
         */
-        diffAlgorithm?: 'legacy' | 'advanced' | IDocumentDiffProvider;
+        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;
+        };
     }
 
     /**
@@ -4025,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.
@@ -4174,6 +4139,10 @@ declare namespace monaco.editor {
          * Model to choose for sticky scroll by default
          */
         defaultModel?: 'outlineModel' | 'foldingProviderModel' | 'indentationModel';
+        /**
+         * Define whether to scroll sticky scroll with editor horizontal scrollbae
+         */
+        scrollWithEditor?: boolean;
     }
 
     /**
@@ -4671,6 +4640,7 @@ declare namespace monaco.editor {
 
     export interface ISmartSelectOptions {
         selectLeadingAndTrailingWhitespace?: boolean;
+        selectSubwords?: boolean;
     }
 
     /**
@@ -4718,149 +4688,171 @@ declare namespace monaco.editor {
         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 {
         acceptSuggestionOnCommitCharacter = 0,
         acceptSuggestionOnEnter = 1,
         accessibilitySupport = 2,
         accessibilityPageSize = 3,
         ariaLabel = 4,
-        autoClosingBrackets = 5,
-        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
+        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: {
@@ -4869,8 +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'>;
@@ -4884,6 +4878,7 @@ 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>>>;
@@ -4947,12 +4942,14 @@ declare namespace monaco.editor {
         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, 'on' | 'off' | 'dimmed'>;
@@ -4980,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>;
@@ -5258,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;
     }
 
     /**
@@ -5326,7 +5365,7 @@ declare namespace monaco.editor {
         /**
          * The target element
          */
-        readonly element: Element | null;
+        readonly element: HTMLElement | null;
         /**
          * The 'approximate' editor position
          */
@@ -5460,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.
@@ -5478,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;
     }
 
     /**
@@ -5790,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.
          */
@@ -5837,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.
          */
@@ -5875,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;
     }
 
     /**
@@ -5914,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
@@ -5922,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.
          */
@@ -5935,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 {
@@ -6045,7 +6079,7 @@ declare namespace monaco.languages {
 
     /**
      * 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.
+     * when a language is encountered during the tokenization of another language.
      * @event
      */
     export function onLanguageEncountered(languageId: string, callback: () => void): IDisposable;
@@ -6920,6 +6954,8 @@ declare namespace monaco.languages {
         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>;
         /**
@@ -6935,6 +6971,17 @@ declare namespace monaco.languages {
          * 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 {
@@ -7306,10 +7353,6 @@ 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[];
     }
 
     /**
@@ -7584,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;
@@ -7668,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[];