monaco-editor-core

  • Version 0.52.2
  • Published
  • 61 MB
  • No dependencies
  • MIT license

Install

npm i monaco-editor-core
yarn add monaco-editor-core
pnpm add monaco-editor-core

Overview

A browser based code editor

Index

Classes

Interfaces

Enums

Type Aliases

Namespaces

Classes

class CancellationTokenSource

class CancellationTokenSource {}

    constructor

    constructor(parent?: CancellationToken);

      property token

      readonly token: CancellationToken;

        method cancel

        cancel: () => void;

          method dispose

          dispose: (cancel?: boolean) => void;

            class Emitter

            class Emitter<T> {}
            • A helper that allows to emit and listen to typed events

            constructor

            constructor();

              property event

              readonly event: IEvent<T>;

                method dispose

                dispose: () => void;

                  method fire

                  fire: (event: T) => void;

                    class KeyMod

                    class KeyMod {}

                      property Alt

                      static readonly Alt: number;

                        property CtrlCmd

                        static readonly CtrlCmd: number;

                          property Shift

                          static readonly Shift: number;

                            property WinCtrl

                            static readonly WinCtrl: number;

                              method chord

                              static chord: (firstPart: number, secondPart: number) => number;

                                class Position

                                class Position {}
                                • A position in the editor.

                                constructor

                                constructor(lineNumber: number, column: number);

                                  property column

                                  readonly column: number;
                                  • column (the first character in a line is between column 1 and column 2)

                                  property lineNumber

                                  readonly lineNumber: number;
                                  • line number (starts at 1)

                                  method clone

                                  clone: () => Position;
                                  • Clone this position.

                                  method compare

                                  static compare: (a: IPosition, b: IPosition) => number;
                                  • A function that compares positions, useful for sorting

                                  method delta

                                  delta: (deltaLineNumber?: number, deltaColumn?: number) => Position;
                                  • Derive a new position from this position.

                                    Parameter deltaLineNumber

                                    line number delta

                                    Parameter deltaColumn

                                    column delta

                                  method equals

                                  static equals: (a: IPosition | null, b: IPosition | null) => boolean;
                                  • Test if this position equals other position

                                  • Test if position a equals position b

                                  method isBefore

                                  static isBefore: (a: IPosition, b: IPosition) => boolean;
                                  • Test if this position is before other position. If the two positions are equal, the result will be false.

                                  • Test if position a is before position b. If the two positions are equal, the result will be false.

                                  method isBeforeOrEqual

                                  static isBeforeOrEqual: (a: IPosition, b: IPosition) => boolean;
                                  • Test if this position is before other position. If the two positions are equal, the result will be true.

                                  • Test if position a is before position b. If the two positions are equal, the result will be true.

                                  method isIPosition

                                  static isIPosition: (obj: any) => obj is IPosition;
                                  • Test if obj is an IPosition.

                                  method lift

                                  static lift: (pos: IPosition) => Position;
                                  • Create a Position from an IPosition.

                                  method toJSON

                                  toJSON: () => IPosition;

                                    method toString

                                    toString: () => string;
                                    • Convert to a human-readable representation.

                                    method with

                                    with: (newLineNumber?: number, newColumn?: number) => Position;
                                    • Create a new position from this position.

                                      Parameter newLineNumber

                                      new line number

                                      Parameter newColumn

                                      new column

                                    class Range

                                    class Range {}
                                    • A range in the editor. (startLineNumber,startColumn) is <= (endLineNumber,endColumn)

                                    constructor

                                    constructor(
                                    startLineNumber: number,
                                    startColumn: number,
                                    endLineNumber: number,
                                    endColumn: number
                                    );

                                      property endColumn

                                      readonly endColumn: number;
                                      • Column on which the range ends in line endLineNumber.

                                      property endLineNumber

                                      readonly endLineNumber: number;
                                      • Line number on which the range ends.

                                      property startColumn

                                      readonly startColumn: number;
                                      • Column on which the range starts in line startLineNumber (starts at 1).

                                      property startLineNumber

                                      readonly startLineNumber: number;
                                      • Line number on which the range starts (starts at 1).

                                      method areIntersecting

                                      static areIntersecting: (a: IRange, b: IRange) => boolean;
                                      • Test if the two ranges are intersecting. If the ranges are touching it returns true.

                                      method areIntersectingOrTouching

                                      static areIntersectingOrTouching: (a: IRange, b: IRange) => boolean;
                                      • Test if the two ranges are touching in any way.

                                      method collapseToEnd

                                      static collapseToEnd: (range: IRange) => Range;
                                      • Create a new empty range using this range's end position.

                                      method collapseToStart

                                      static collapseToStart: (range: IRange) => Range;
                                      • Create a new empty range using this range's start position.

                                      method compareRangesUsingEnds

                                      static compareRangesUsingEnds: (a: IRange, b: IRange) => number;
                                      • A function that compares ranges, useful for sorting ranges It will first compare ranges on the endPosition and then on the startPosition

                                      method compareRangesUsingStarts

                                      static compareRangesUsingStarts: (
                                      a: IRange | null | undefined,
                                      b: IRange | null | undefined
                                      ) => number;
                                      • A function that compares ranges, useful for sorting ranges It will first compare ranges on the startPosition and then on the endPosition

                                      method containsPosition

                                      static containsPosition: (range: IRange, position: IPosition) => boolean;
                                      • Test if position is in this range. If the position is at the edges, will return true.

                                      • Test if position is in range. If the position is at the edges, will return true.

                                      method containsRange

                                      static containsRange: (range: IRange, otherRange: IRange) => boolean;
                                      • Test if range is in this range. If the range is equal to this range, will return true.

                                      • Test if otherRange is in range. If the ranges are equal, will return true.

                                      method delta

                                      delta: (lineCount: number) => Range;
                                      • Moves the range by the given amount of lines.

                                      method equalsRange

                                      static equalsRange: (
                                      a: IRange | null | undefined,
                                      b: IRange | null | undefined
                                      ) => boolean;
                                      • Test if this range equals other.

                                      • Test if range a equals b.

                                      method fromPositions

                                      static fromPositions: (start: IPosition, end?: IPosition) => Range;

                                        method getEndPosition

                                        static getEndPosition: (range: IRange) => Position;
                                        • Return the end position (which will be after or equal to the start position)

                                        method getStartPosition

                                        static getStartPosition: (range: IRange) => Position;
                                        • Return the start position (which will be before or equal to the end position)

                                        method intersectRanges

                                        static intersectRanges: (a: IRange, b: IRange) => Range | null;
                                        • A intersection of the two ranges.

                                        method isEmpty

                                        static isEmpty: (range: IRange) => boolean;
                                        • Test if this range is empty.

                                        • Test if range is empty.

                                        method isIRange

                                        static isIRange: (obj: any) => obj is IRange;
                                        • Test if obj is an IRange.

                                        method lift

                                        static lift: {
                                        (range: undefined | null): null;
                                        (range: IRange): Range;
                                        (range: IRange): Range;
                                        };
                                        • Create a Range from an IRange.

                                        method plusRange

                                        static plusRange: (a: IRange, b: IRange) => Range;
                                        • A reunion of the two ranges. The smallest position will be used as the start point, and the largest one as the end point.

                                        method setEndPosition

                                        setEndPosition: (endLineNumber: number, endColumn: number) => Range;
                                        • Create a new range using this range's start position, and using endLineNumber and endColumn as the end position.

                                        method setStartPosition

                                        setStartPosition: (startLineNumber: number, startColumn: number) => Range;
                                        • Create a new range using this range's end position, and using startLineNumber and startColumn as the start position.

                                        method spansMultipleLines

                                        static spansMultipleLines: (range: IRange) => boolean;
                                        • Test if the range spans multiple lines.

                                        method strictContainsRange

                                        static strictContainsRange: (range: IRange, otherRange: IRange) => boolean;
                                        • Test if range is strictly in this range. range must start after and end before this range for the result to be true.

                                        • Test if otherRange is strictly in range (must start after, and end before). If the ranges are equal, will return false.

                                        method toJSON

                                        toJSON: () => IRange;

                                          method toString

                                          toString: () => string;
                                          • Transform to a user presentable string representation.

                                          class Selection

                                          class Selection extends Range {}
                                          • A selection in the editor. The selection is a range that has an orientation.

                                          constructor

                                          constructor(
                                          selectionStartLineNumber: number,
                                          selectionStartColumn: number,
                                          positionLineNumber: number,
                                          positionColumn: number
                                          );

                                            property positionColumn

                                            readonly positionColumn: number;
                                            • The column on positionLineNumber where the selection has ended.

                                            property positionLineNumber

                                            readonly positionLineNumber: number;
                                            • The line number on which the selection has ended.

                                            property selectionStartColumn

                                            readonly selectionStartColumn: number;
                                            • The column on selectionStartLineNumber where the selection has started.

                                            property selectionStartLineNumber

                                            readonly selectionStartLineNumber: number;
                                            • The line number on which the selection has started.

                                            method createWithDirection

                                            static createWithDirection: (
                                            startLineNumber: number,
                                            startColumn: number,
                                            endLineNumber: number,
                                            endColumn: number,
                                            direction: SelectionDirection
                                            ) => Selection;
                                            • Create with a direction.

                                            method equalsSelection

                                            equalsSelection: (other: ISelection) => boolean;
                                            • Test if equals other selection.

                                            method fromPositions

                                            static fromPositions: (start: IPosition, end?: IPosition) => Selection;
                                            • Create a Selection from one or two positions

                                            method fromRange

                                            static fromRange: (range: Range, direction: SelectionDirection) => Selection;
                                            • Creates a Selection from a range, given a direction.

                                            method getDirection

                                            getDirection: () => SelectionDirection;
                                            • Get directions (LTR or RTL).

                                            method getPosition

                                            getPosition: () => Position;
                                            • Get the position at positionLineNumber and positionColumn.

                                            method getSelectionStart

                                            getSelectionStart: () => Position;
                                            • Get the position at the start of the selection.

                                            method isISelection

                                            static isISelection: (obj: any) => obj is ISelection;
                                            • Test if obj is an ISelection.

                                            method liftSelection

                                            static liftSelection: (sel: ISelection) => Selection;
                                            • Create a Selection from an ISelection.

                                            method selectionsArrEqual

                                            static selectionsArrEqual: (a: ISelection[], b: ISelection[]) => boolean;
                                            • a equals b.

                                            method selectionsEqual

                                            static selectionsEqual: (a: ISelection, b: ISelection) => boolean;
                                            • Test if the two selections are equal.

                                            method setEndPosition

                                            setEndPosition: (endLineNumber: number, endColumn: number) => Selection;
                                            • Create a new selection with a different positionLineNumber and positionColumn.

                                            method setStartPosition

                                            setStartPosition: (startLineNumber: number, startColumn: number) => Selection;
                                            • Create a new selection with a different selectionStartLineNumber and selectionStartColumn.

                                            method toString

                                            toString: () => string;
                                            • Transform to a human-readable representation.

                                            class Token

                                            class Token {}

                                              constructor

                                              constructor(offset: number, type: string, language: string);

                                                property language

                                                readonly language: string;

                                                  property offset

                                                  readonly offset: number;

                                                    property type

                                                    readonly type: string;

                                                      method toString

                                                      toString: () => string;

                                                        class Uri

                                                        class Uri implements UriComponents {}
                                                        • Uniform Resource Identifier (Uri) http://tools.ietf.org/html/rfc3986. This class is a simple parser which creates the basic component parts (http://tools.ietf.org/html/rfc3986#section-3) with minimal validation and encoding.

                                                          foo://example.com:8042/over/there?name=ferret#nose
                                                          \_/ \______________/\_________/ \_________/ \__/
                                                          | | | | |
                                                          scheme authority path query fragment
                                                          | _____________________|__
                                                          / \ / \
                                                          urn:example:animal:ferret:nose

                                                        property authority

                                                        readonly authority: string;
                                                        • authority is the 'www.example.com' part of 'http://www.example.com/some/path?query#fragment'. The part between the first double slashes and the next slash.

                                                        property fragment

                                                        readonly fragment: string;
                                                        • fragment is the 'fragment' part of 'http://www.example.com/some/path?query#fragment'.

                                                        property fsPath

                                                        readonly fsPath: string;
                                                        • Returns a string representing the corresponding file system path of this Uri. Will handle UNC paths, normalizes windows drive letters to lower-case, and uses the platform specific path separator.

                                                          * Will *not* validate the path for invalid characters and semantics. * Will *not* look at the scheme of this Uri. * The result shall *not* be used for display purposes but for accessing a file on disk.

                                                          The *difference* to Uri#path is the use of the platform specific separator and the handling of UNC paths. See the below sample of a file-uri with an authority (UNC path).

                                                          const u = Uri.parse('file://server/c$/folder/file.txt')
                                                          u.authority === 'server'
                                                          u.path === '/shares/c$/file.txt'
                                                          u.fsPath === '\\server\c$\folder\file.txt'

                                                          Using Uri#path to read a file (using fs-apis) would not be enough because parts of the path, namely the server name, would be missing. Therefore Uri#fsPath exists - it's sugar to ease working with URIs that represent files on disk (file scheme).

                                                        property path

                                                        readonly path: string;
                                                        • path is the '/some/path' part of 'http://www.example.com/some/path?query#fragment'.

                                                        property query

                                                        readonly query: string;
                                                        • query is the 'query' part of 'http://www.example.com/some/path?query#fragment'.

                                                        property scheme

                                                        readonly scheme: string;
                                                        • scheme is the 'http' part of 'http://www.example.com/some/path?query#fragment'. The part before the first colon.

                                                        method file

                                                        static file: (path: string) => Uri;
                                                        • Creates a new Uri from a file system path, e.g. c:\my\files, /usr/home, or \\server\share\some\path.

                                                          The *difference* between Uri#parse and Uri#file is that the latter treats the argument as path, not as stringified-uri. E.g. Uri.file(path) is **not the same as** Uri.parse('file://' + path) because the path might contain characters that are interpreted (# and ?). See the following sample:

                                                          const good = Uri.file('/coding/c#/project1');
                                                          good.scheme === 'file';
                                                          good.path === '/coding/c#/project1';
                                                          good.fragment === '';
                                                          const bad = Uri.parse('file://' + '/coding/c#/project1');
                                                          bad.scheme === 'file';
                                                          bad.path === '/coding/c'; // path is now broken
                                                          bad.fragment === '/project1';

                                                          Parameter path

                                                          A file system path (see Uri#fsPath)

                                                        method from

                                                        static from: (components: UriComponents, strict?: boolean) => 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

                                                        method isUri

                                                        static isUri: (thing: any) => thing is Uri;

                                                          method joinPath

                                                          static joinPath: (uri: Uri, ...pathFragment: string[]) => Uri;
                                                          • Join a Uri path with path fragments and normalizes the resulting path.

                                                            Parameter uri

                                                            The input Uri.

                                                            Parameter pathFragment

                                                            The path fragment to add to the Uri path.

                                                            Returns

                                                            The resulting Uri.

                                                          method parse

                                                          static parse: (value: string, _strict?: boolean) => Uri;
                                                          • Creates a new Uri from a string, e.g. http://www.example.com/some/path, file:///usr/home, or scheme:with/path.

                                                            Parameter value

                                                            A string which represents an Uri (see Uri#toString).

                                                          method revive

                                                          static revive: {
                                                          (data: UriComponents | Uri): Uri;
                                                          (data: Uri | UriComponents): Uri;
                                                          (data: Uri | UriComponents): Uri;
                                                          (data: Uri | UriComponents): Uri;
                                                          };
                                                          • 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 Uri.from when received "untrusted" uri components such as command arguments or data from storage.

                                                            Parameter data

                                                            The Uri components or Uri to revive.

                                                            Returns

                                                            The revived Uri or undefined or null.

                                                          method toJSON

                                                          toJSON: () => UriComponents;

                                                            method toString

                                                            toString: (skipEncoding?: boolean) => string;
                                                            • Creates a string representation for this Uri. It's guaranteed that calling Uri.parse with the result of this function creates an Uri which is equal to this Uri.

                                                              * The result shall *not* be used for display purposes but for externalization or transport. * The result will be encoded using the percentage encoding and encoding happens mostly ignore the scheme-specific encoding rules.

                                                              Parameter skipEncoding

                                                              Do not encode the result, default is false

                                                            method with

                                                            with: (change: {
                                                            scheme?: string;
                                                            authority?: string | null;
                                                            path?: string | null;
                                                            query?: string | null;
                                                            fragment?: string | null;
                                                            }) => Uri;

                                                              Interfaces

                                                              interface CancellationToken

                                                              interface CancellationToken {}

                                                                property isCancellationRequested

                                                                readonly isCancellationRequested: boolean;
                                                                • A flag signalling is cancellation has been requested.

                                                                property onCancellationRequested

                                                                readonly onCancellationRequested: (
                                                                listener: (e: any) => any,
                                                                thisArgs?: any,
                                                                disposables?: IDisposable[]
                                                                ) => IDisposable;
                                                                • An event which fires when cancellation is requested. This event only ever fires once as cancellation can only happen once. Listeners that are registered after cancellation will be called (next event loop run), but also only once.

                                                                interface Environment

                                                                interface Environment {}

                                                                  property baseUrl

                                                                  baseUrl?: string;
                                                                  • The base url where the editor sources are found (which contains the vs folder)

                                                                  property globalAPI

                                                                  globalAPI?: boolean;
                                                                  • Define a global monaco symbol. This is true by default in AMD and false by default in ESM.

                                                                  method createTrustedTypesPolicy

                                                                  createTrustedTypesPolicy: (
                                                                  policyName: string,
                                                                  policyOptions?: ITrustedTypePolicyOptions
                                                                  ) => undefined | ITrustedTypePolicy;
                                                                  • Create a trusted types policy (same API as window.trustedTypes.createPolicy)

                                                                  method getWorker

                                                                  getWorker: (workerId: string, label: string) => Promise<Worker> | Worker;
                                                                  • A web worker factory. NOTE: If getWorker is defined, getWorkerUrl is not invoked.

                                                                  method getWorkerUrl

                                                                  getWorkerUrl: (workerId: string, label: string) => string;
                                                                  • Return the location for web worker scripts. NOTE: If getWorker is defined, getWorkerUrl is not invoked.

                                                                  interface IDisposable

                                                                  interface IDisposable {}

                                                                    method dispose

                                                                    dispose: () => void;

                                                                      interface IEvent

                                                                      interface IEvent<T> {}

                                                                        call signature

                                                                        (listener: (e: T) => any, thisArg?: any): IDisposable;

                                                                          interface IKeyboardEvent

                                                                          interface IKeyboardEvent {}

                                                                            property altGraphKey

                                                                            readonly altGraphKey: boolean;

                                                                              property altKey

                                                                              readonly altKey: boolean;

                                                                                property browserEvent

                                                                                readonly browserEvent: KeyboardEvent;

                                                                                  property code

                                                                                  readonly code: string;

                                                                                    property ctrlKey

                                                                                    readonly ctrlKey: boolean;

                                                                                      property keyCode

                                                                                      readonly keyCode: KeyCode;

                                                                                        property metaKey

                                                                                        readonly metaKey: boolean;

                                                                                          property shiftKey

                                                                                          readonly shiftKey: boolean;

                                                                                            property target

                                                                                            readonly target: HTMLElement;

                                                                                              method equals

                                                                                              equals: (keybinding: number) => boolean;

                                                                                                method preventDefault

                                                                                                preventDefault: () => void;

                                                                                                  method stopPropagation

                                                                                                  stopPropagation: () => void;

                                                                                                    interface IMarkdownString

                                                                                                    interface IMarkdownString {}

                                                                                                      property baseUri

                                                                                                      readonly baseUri?: UriComponents;

                                                                                                        property isTrusted

                                                                                                        readonly isTrusted?: boolean | MarkdownStringTrustedOptions;

                                                                                                          property supportHtml

                                                                                                          readonly supportHtml?: boolean;

                                                                                                            property supportThemeIcons

                                                                                                            readonly supportThemeIcons?: boolean;

                                                                                                              property uris

                                                                                                              uris?: {
                                                                                                              [href: string]: UriComponents;
                                                                                                              };

                                                                                                                property value

                                                                                                                readonly value: string;

                                                                                                                  interface IMouseEvent

                                                                                                                  interface IMouseEvent {}

                                                                                                                    property altKey

                                                                                                                    readonly altKey: boolean;

                                                                                                                      property browserEvent

                                                                                                                      readonly browserEvent: MouseEvent;

                                                                                                                        property buttons

                                                                                                                        readonly buttons: number;

                                                                                                                          property ctrlKey

                                                                                                                          readonly ctrlKey: boolean;

                                                                                                                            property detail

                                                                                                                            readonly detail: number;

                                                                                                                              property leftButton

                                                                                                                              readonly leftButton: boolean;

                                                                                                                                property metaKey

                                                                                                                                readonly metaKey: boolean;

                                                                                                                                  property middleButton

                                                                                                                                  readonly middleButton: boolean;

                                                                                                                                    property posx

                                                                                                                                    readonly posx: number;

                                                                                                                                      property posy

                                                                                                                                      readonly posy: number;

                                                                                                                                        property rightButton

                                                                                                                                        readonly rightButton: boolean;

                                                                                                                                          property shiftKey

                                                                                                                                          readonly shiftKey: boolean;

                                                                                                                                            property target

                                                                                                                                            readonly target: HTMLElement;

                                                                                                                                              property timestamp

                                                                                                                                              readonly timestamp: number;

                                                                                                                                                method preventDefault

                                                                                                                                                preventDefault: () => void;

                                                                                                                                                  method stopPropagation

                                                                                                                                                  stopPropagation: () => void;

                                                                                                                                                    interface IPosition

                                                                                                                                                    interface IPosition {}
                                                                                                                                                    • A position in the editor. This interface is suitable for serialization.

                                                                                                                                                    property column

                                                                                                                                                    readonly column: number;
                                                                                                                                                    • column (the first character in a line is between column 1 and column 2)

                                                                                                                                                    property lineNumber

                                                                                                                                                    readonly lineNumber: number;
                                                                                                                                                    • line number (starts at 1)

                                                                                                                                                    interface IRange

                                                                                                                                                    interface IRange {}
                                                                                                                                                    • A range in the editor. This interface is suitable for serialization.

                                                                                                                                                    property endColumn

                                                                                                                                                    readonly endColumn: number;
                                                                                                                                                    • Column on which the range ends in line endLineNumber.

                                                                                                                                                    property endLineNumber

                                                                                                                                                    readonly endLineNumber: number;
                                                                                                                                                    • Line number on which the range ends.

                                                                                                                                                    property startColumn

                                                                                                                                                    readonly startColumn: number;
                                                                                                                                                    • Column on which the range starts in line startLineNumber (starts at 1).

                                                                                                                                                    property startLineNumber

                                                                                                                                                    readonly startLineNumber: number;
                                                                                                                                                    • Line number on which the range starts (starts at 1).

                                                                                                                                                    interface IScrollEvent

                                                                                                                                                    interface IScrollEvent {}

                                                                                                                                                      property scrollHeight

                                                                                                                                                      readonly scrollHeight: number;

                                                                                                                                                        property scrollHeightChanged

                                                                                                                                                        readonly scrollHeightChanged: boolean;

                                                                                                                                                          property scrollLeft

                                                                                                                                                          readonly scrollLeft: number;

                                                                                                                                                            property scrollLeftChanged

                                                                                                                                                            readonly scrollLeftChanged: boolean;

                                                                                                                                                              property scrollTop

                                                                                                                                                              readonly scrollTop: number;

                                                                                                                                                                property scrollTopChanged

                                                                                                                                                                readonly scrollTopChanged: boolean;

                                                                                                                                                                  property scrollWidth

                                                                                                                                                                  readonly scrollWidth: number;

                                                                                                                                                                    property scrollWidthChanged

                                                                                                                                                                    readonly scrollWidthChanged: boolean;

                                                                                                                                                                      interface ISelection

                                                                                                                                                                      interface ISelection {}
                                                                                                                                                                      • A selection in the editor. The selection is a range that has an orientation.

                                                                                                                                                                      property positionColumn

                                                                                                                                                                      readonly positionColumn: number;
                                                                                                                                                                      • The column on positionLineNumber where the selection has ended.

                                                                                                                                                                      property positionLineNumber

                                                                                                                                                                      readonly positionLineNumber: number;
                                                                                                                                                                      • The line number on which the selection has ended.

                                                                                                                                                                      property selectionStartColumn

                                                                                                                                                                      readonly selectionStartColumn: number;
                                                                                                                                                                      • The column on selectionStartLineNumber where the selection has started.

                                                                                                                                                                      property selectionStartLineNumber

                                                                                                                                                                      readonly selectionStartLineNumber: number;
                                                                                                                                                                      • The line number on which the selection has started.

                                                                                                                                                                      interface ITrustedTypePolicy

                                                                                                                                                                      interface ITrustedTypePolicy {}

                                                                                                                                                                        property name

                                                                                                                                                                        readonly name: string;

                                                                                                                                                                          method createHTML

                                                                                                                                                                          createHTML: (input: string) => any;

                                                                                                                                                                            method createScript

                                                                                                                                                                            createScript: (input: string) => any;

                                                                                                                                                                              method createScriptURL

                                                                                                                                                                              createScriptURL: (input: string) => any;

                                                                                                                                                                                interface ITrustedTypePolicyOptions

                                                                                                                                                                                interface ITrustedTypePolicyOptions {}

                                                                                                                                                                                  property createHTML

                                                                                                                                                                                  createHTML?: (input: string, ...arguments: any[]) => string;

                                                                                                                                                                                    property createScript

                                                                                                                                                                                    createScript?: (input: string, ...arguments: any[]) => string;

                                                                                                                                                                                      property createScriptURL

                                                                                                                                                                                      createScriptURL?: (input: string, ...arguments: any[]) => string;

                                                                                                                                                                                        interface MarkdownStringTrustedOptions

                                                                                                                                                                                        interface MarkdownStringTrustedOptions {}

                                                                                                                                                                                          property enabledCommands

                                                                                                                                                                                          readonly enabledCommands: readonly string[];

                                                                                                                                                                                            interface UriComponents

                                                                                                                                                                                            interface UriComponents {}

                                                                                                                                                                                              property authority

                                                                                                                                                                                              authority?: string;

                                                                                                                                                                                                property fragment

                                                                                                                                                                                                fragment?: string;

                                                                                                                                                                                                  property path

                                                                                                                                                                                                  path?: string;

                                                                                                                                                                                                    property query

                                                                                                                                                                                                    query?: string;

                                                                                                                                                                                                      property scheme

                                                                                                                                                                                                      scheme: string;

                                                                                                                                                                                                        interface Window

                                                                                                                                                                                                        interface Window {}

                                                                                                                                                                                                          property MonacoEnvironment

                                                                                                                                                                                                          MonacoEnvironment?: Environment | undefined;

                                                                                                                                                                                                            Enums

                                                                                                                                                                                                            enum KeyCode

                                                                                                                                                                                                            enum KeyCode {
                                                                                                                                                                                                            DependsOnKbLayout = -1,
                                                                                                                                                                                                            Unknown = 0,
                                                                                                                                                                                                            Backspace = 1,
                                                                                                                                                                                                            Tab = 2,
                                                                                                                                                                                                            Enter = 3,
                                                                                                                                                                                                            Shift = 4,
                                                                                                                                                                                                            Ctrl = 5,
                                                                                                                                                                                                            Alt = 6,
                                                                                                                                                                                                            PauseBreak = 7,
                                                                                                                                                                                                            CapsLock = 8,
                                                                                                                                                                                                            Escape = 9,
                                                                                                                                                                                                            Space = 10,
                                                                                                                                                                                                            PageUp = 11,
                                                                                                                                                                                                            PageDown = 12,
                                                                                                                                                                                                            End = 13,
                                                                                                                                                                                                            Home = 14,
                                                                                                                                                                                                            LeftArrow = 15,
                                                                                                                                                                                                            UpArrow = 16,
                                                                                                                                                                                                            RightArrow = 17,
                                                                                                                                                                                                            DownArrow = 18,
                                                                                                                                                                                                            Insert = 19,
                                                                                                                                                                                                            Delete = 20,
                                                                                                                                                                                                            Digit0 = 21,
                                                                                                                                                                                                            Digit1 = 22,
                                                                                                                                                                                                            Digit2 = 23,
                                                                                                                                                                                                            Digit3 = 24,
                                                                                                                                                                                                            Digit4 = 25,
                                                                                                                                                                                                            Digit5 = 26,
                                                                                                                                                                                                            Digit6 = 27,
                                                                                                                                                                                                            Digit7 = 28,
                                                                                                                                                                                                            Digit8 = 29,
                                                                                                                                                                                                            Digit9 = 30,
                                                                                                                                                                                                            KeyA = 31,
                                                                                                                                                                                                            KeyB = 32,
                                                                                                                                                                                                            KeyC = 33,
                                                                                                                                                                                                            KeyD = 34,
                                                                                                                                                                                                            KeyE = 35,
                                                                                                                                                                                                            KeyF = 36,
                                                                                                                                                                                                            KeyG = 37,
                                                                                                                                                                                                            KeyH = 38,
                                                                                                                                                                                                            KeyI = 39,
                                                                                                                                                                                                            KeyJ = 40,
                                                                                                                                                                                                            KeyK = 41,
                                                                                                                                                                                                            KeyL = 42,
                                                                                                                                                                                                            KeyM = 43,
                                                                                                                                                                                                            KeyN = 44,
                                                                                                                                                                                                            KeyO = 45,
                                                                                                                                                                                                            KeyP = 46,
                                                                                                                                                                                                            KeyQ = 47,
                                                                                                                                                                                                            KeyR = 48,
                                                                                                                                                                                                            KeyS = 49,
                                                                                                                                                                                                            KeyT = 50,
                                                                                                                                                                                                            KeyU = 51,
                                                                                                                                                                                                            KeyV = 52,
                                                                                                                                                                                                            KeyW = 53,
                                                                                                                                                                                                            KeyX = 54,
                                                                                                                                                                                                            KeyY = 55,
                                                                                                                                                                                                            KeyZ = 56,
                                                                                                                                                                                                            Meta = 57,
                                                                                                                                                                                                            ContextMenu = 58,
                                                                                                                                                                                                            F1 = 59,
                                                                                                                                                                                                            F2 = 60,
                                                                                                                                                                                                            F3 = 61,
                                                                                                                                                                                                            F4 = 62,
                                                                                                                                                                                                            F5 = 63,
                                                                                                                                                                                                            F6 = 64,
                                                                                                                                                                                                            F7 = 65,
                                                                                                                                                                                                            F8 = 66,
                                                                                                                                                                                                            F9 = 67,
                                                                                                                                                                                                            F10 = 68,
                                                                                                                                                                                                            F11 = 69,
                                                                                                                                                                                                            F12 = 70,
                                                                                                                                                                                                            F13 = 71,
                                                                                                                                                                                                            F14 = 72,
                                                                                                                                                                                                            F15 = 73,
                                                                                                                                                                                                            F16 = 74,
                                                                                                                                                                                                            F17 = 75,
                                                                                                                                                                                                            F18 = 76,
                                                                                                                                                                                                            F19 = 77,
                                                                                                                                                                                                            F20 = 78,
                                                                                                                                                                                                            F21 = 79,
                                                                                                                                                                                                            F22 = 80,
                                                                                                                                                                                                            F23 = 81,
                                                                                                                                                                                                            F24 = 82,
                                                                                                                                                                                                            NumLock = 83,
                                                                                                                                                                                                            ScrollLock = 84,
                                                                                                                                                                                                            Semicolon = 85,
                                                                                                                                                                                                            Equal = 86,
                                                                                                                                                                                                            Comma = 87,
                                                                                                                                                                                                            Minus = 88,
                                                                                                                                                                                                            Period = 89,
                                                                                                                                                                                                            Slash = 90,
                                                                                                                                                                                                            Backquote = 91,
                                                                                                                                                                                                            BracketLeft = 92,
                                                                                                                                                                                                            Backslash = 93,
                                                                                                                                                                                                            BracketRight = 94,
                                                                                                                                                                                                            Quote = 95,
                                                                                                                                                                                                            OEM_8 = 96,
                                                                                                                                                                                                            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,
                                                                                                                                                                                                            KEY_IN_COMPOSITION = 114,
                                                                                                                                                                                                            ABNT_C1 = 115,
                                                                                                                                                                                                            ABNT_C2 = 116,
                                                                                                                                                                                                            AudioVolumeMute = 117,
                                                                                                                                                                                                            AudioVolumeUp = 118,
                                                                                                                                                                                                            AudioVolumeDown = 119,
                                                                                                                                                                                                            BrowserSearch = 120,
                                                                                                                                                                                                            BrowserHome = 121,
                                                                                                                                                                                                            BrowserBack = 122,
                                                                                                                                                                                                            BrowserForward = 123,
                                                                                                                                                                                                            MediaTrackNext = 124,
                                                                                                                                                                                                            MediaTrackPrevious = 125,
                                                                                                                                                                                                            MediaStop = 126,
                                                                                                                                                                                                            MediaPlayPause = 127,
                                                                                                                                                                                                            LaunchMediaPlayer = 128,
                                                                                                                                                                                                            LaunchMail = 129,
                                                                                                                                                                                                            LaunchApp2 = 130,
                                                                                                                                                                                                            Clear = 131,
                                                                                                                                                                                                            MAX_VALUE = 132,
                                                                                                                                                                                                            }
                                                                                                                                                                                                            • Virtual Key Codes, the value does not hold any inherent meaning. Inspired somewhat from https://msdn.microsoft.com/en-us/library/windows/desktop/dd375731(v=vs.85).aspx But these are "more general", as they should work across browsers & OS`s.

                                                                                                                                                                                                            member ABNT_C1

                                                                                                                                                                                                            ABNT_C1 = 115

                                                                                                                                                                                                              member ABNT_C2

                                                                                                                                                                                                              ABNT_C2 = 116

                                                                                                                                                                                                                member Alt

                                                                                                                                                                                                                Alt = 6

                                                                                                                                                                                                                  member AudioVolumeDown

                                                                                                                                                                                                                  AudioVolumeDown = 119

                                                                                                                                                                                                                    member AudioVolumeMute

                                                                                                                                                                                                                    AudioVolumeMute = 117

                                                                                                                                                                                                                      member AudioVolumeUp

                                                                                                                                                                                                                      AudioVolumeUp = 118

                                                                                                                                                                                                                        member Backquote

                                                                                                                                                                                                                        Backquote = 91
                                                                                                                                                                                                                        • Used for miscellaneous characters; it can vary by keyboard. For the US standard keyboard, the '`~' key

                                                                                                                                                                                                                        member Backslash

                                                                                                                                                                                                                        Backslash = 93
                                                                                                                                                                                                                        • Used for miscellaneous characters; it can vary by keyboard. For the US standard keyboard, the '|' key

                                                                                                                                                                                                                        member Backspace

                                                                                                                                                                                                                        Backspace = 1

                                                                                                                                                                                                                          member BracketLeft

                                                                                                                                                                                                                          BracketLeft = 92
                                                                                                                                                                                                                          • Used for miscellaneous characters; it can vary by keyboard. For the US standard keyboard, the '[{' key

                                                                                                                                                                                                                          member BracketRight

                                                                                                                                                                                                                          BracketRight = 94
                                                                                                                                                                                                                          • Used for miscellaneous characters; it can vary by keyboard. For the US standard keyboard, the ']}' key

                                                                                                                                                                                                                          member BrowserBack

                                                                                                                                                                                                                          BrowserBack = 122

                                                                                                                                                                                                                            member BrowserForward

                                                                                                                                                                                                                            BrowserForward = 123

                                                                                                                                                                                                                              member BrowserHome

                                                                                                                                                                                                                              BrowserHome = 121

                                                                                                                                                                                                                                member BrowserSearch

                                                                                                                                                                                                                                BrowserSearch = 120

                                                                                                                                                                                                                                  member CapsLock

                                                                                                                                                                                                                                  CapsLock = 8

                                                                                                                                                                                                                                    member Clear

                                                                                                                                                                                                                                    Clear = 131
                                                                                                                                                                                                                                    • VK_CLEAR, 0x0C, CLEAR key

                                                                                                                                                                                                                                    member Comma

                                                                                                                                                                                                                                    Comma = 87
                                                                                                                                                                                                                                    • For any country/region, the ',' key For the US standard keyboard, the ',<' key

                                                                                                                                                                                                                                    member ContextMenu

                                                                                                                                                                                                                                    ContextMenu = 58

                                                                                                                                                                                                                                      member Ctrl

                                                                                                                                                                                                                                      Ctrl = 5

                                                                                                                                                                                                                                        member Delete

                                                                                                                                                                                                                                        Delete = 20

                                                                                                                                                                                                                                          member DependsOnKbLayout

                                                                                                                                                                                                                                          DependsOnKbLayout = -1

                                                                                                                                                                                                                                            member Digit0

                                                                                                                                                                                                                                            Digit0 = 21

                                                                                                                                                                                                                                              member Digit1

                                                                                                                                                                                                                                              Digit1 = 22

                                                                                                                                                                                                                                                member Digit2

                                                                                                                                                                                                                                                Digit2 = 23

                                                                                                                                                                                                                                                  member Digit3

                                                                                                                                                                                                                                                  Digit3 = 24

                                                                                                                                                                                                                                                    member Digit4

                                                                                                                                                                                                                                                    Digit4 = 25

                                                                                                                                                                                                                                                      member Digit5

                                                                                                                                                                                                                                                      Digit5 = 26

                                                                                                                                                                                                                                                        member Digit6

                                                                                                                                                                                                                                                        Digit6 = 27

                                                                                                                                                                                                                                                          member Digit7

                                                                                                                                                                                                                                                          Digit7 = 28

                                                                                                                                                                                                                                                            member Digit8

                                                                                                                                                                                                                                                            Digit8 = 29

                                                                                                                                                                                                                                                              member Digit9

                                                                                                                                                                                                                                                              Digit9 = 30

                                                                                                                                                                                                                                                                member DownArrow

                                                                                                                                                                                                                                                                DownArrow = 18

                                                                                                                                                                                                                                                                  member End

                                                                                                                                                                                                                                                                  End = 13

                                                                                                                                                                                                                                                                    member Enter

                                                                                                                                                                                                                                                                    Enter = 3

                                                                                                                                                                                                                                                                      member Equal

                                                                                                                                                                                                                                                                      Equal = 86
                                                                                                                                                                                                                                                                      • For any country/region, the '+' key For the US standard keyboard, the '=+' key

                                                                                                                                                                                                                                                                      member Escape

                                                                                                                                                                                                                                                                      Escape = 9

                                                                                                                                                                                                                                                                        member F1

                                                                                                                                                                                                                                                                        F1 = 59

                                                                                                                                                                                                                                                                          member F10

                                                                                                                                                                                                                                                                          F10 = 68

                                                                                                                                                                                                                                                                            member F11

                                                                                                                                                                                                                                                                            F11 = 69

                                                                                                                                                                                                                                                                              member F12

                                                                                                                                                                                                                                                                              F12 = 70

                                                                                                                                                                                                                                                                                member F13

                                                                                                                                                                                                                                                                                F13 = 71

                                                                                                                                                                                                                                                                                  member F14

                                                                                                                                                                                                                                                                                  F14 = 72

                                                                                                                                                                                                                                                                                    member F15

                                                                                                                                                                                                                                                                                    F15 = 73

                                                                                                                                                                                                                                                                                      member F16

                                                                                                                                                                                                                                                                                      F16 = 74

                                                                                                                                                                                                                                                                                        member F17

                                                                                                                                                                                                                                                                                        F17 = 75

                                                                                                                                                                                                                                                                                          member F18

                                                                                                                                                                                                                                                                                          F18 = 76

                                                                                                                                                                                                                                                                                            member F19

                                                                                                                                                                                                                                                                                            F19 = 77

                                                                                                                                                                                                                                                                                              member F2

                                                                                                                                                                                                                                                                                              F2 = 60

                                                                                                                                                                                                                                                                                                member F20

                                                                                                                                                                                                                                                                                                F20 = 78

                                                                                                                                                                                                                                                                                                  member F21

                                                                                                                                                                                                                                                                                                  F21 = 79

                                                                                                                                                                                                                                                                                                    member F22

                                                                                                                                                                                                                                                                                                    F22 = 80

                                                                                                                                                                                                                                                                                                      member F23

                                                                                                                                                                                                                                                                                                      F23 = 81

                                                                                                                                                                                                                                                                                                        member F24

                                                                                                                                                                                                                                                                                                        F24 = 82

                                                                                                                                                                                                                                                                                                          member F3

                                                                                                                                                                                                                                                                                                          F3 = 61

                                                                                                                                                                                                                                                                                                            member F4

                                                                                                                                                                                                                                                                                                            F4 = 62

                                                                                                                                                                                                                                                                                                              member F5

                                                                                                                                                                                                                                                                                                              F5 = 63

                                                                                                                                                                                                                                                                                                                member F6

                                                                                                                                                                                                                                                                                                                F6 = 64

                                                                                                                                                                                                                                                                                                                  member F7

                                                                                                                                                                                                                                                                                                                  F7 = 65

                                                                                                                                                                                                                                                                                                                    member F8

                                                                                                                                                                                                                                                                                                                    F8 = 66

                                                                                                                                                                                                                                                                                                                      member F9

                                                                                                                                                                                                                                                                                                                      F9 = 67

                                                                                                                                                                                                                                                                                                                        member Home

                                                                                                                                                                                                                                                                                                                        Home = 14

                                                                                                                                                                                                                                                                                                                          member Insert

                                                                                                                                                                                                                                                                                                                          Insert = 19

                                                                                                                                                                                                                                                                                                                            member IntlBackslash

                                                                                                                                                                                                                                                                                                                            IntlBackslash = 97
                                                                                                                                                                                                                                                                                                                            • Either the angle bracket key or the backslash key on the RT 102-key keyboard.

                                                                                                                                                                                                                                                                                                                            member KEY_IN_COMPOSITION

                                                                                                                                                                                                                                                                                                                            KEY_IN_COMPOSITION = 114
                                                                                                                                                                                                                                                                                                                            • Cover all key codes when IME is processing input.

                                                                                                                                                                                                                                                                                                                            member KeyA

                                                                                                                                                                                                                                                                                                                            KeyA = 31

                                                                                                                                                                                                                                                                                                                              member KeyB

                                                                                                                                                                                                                                                                                                                              KeyB = 32

                                                                                                                                                                                                                                                                                                                                member KeyC

                                                                                                                                                                                                                                                                                                                                KeyC = 33

                                                                                                                                                                                                                                                                                                                                  member KeyD

                                                                                                                                                                                                                                                                                                                                  KeyD = 34

                                                                                                                                                                                                                                                                                                                                    member KeyE

                                                                                                                                                                                                                                                                                                                                    KeyE = 35

                                                                                                                                                                                                                                                                                                                                      member KeyF

                                                                                                                                                                                                                                                                                                                                      KeyF = 36

                                                                                                                                                                                                                                                                                                                                        member KeyG

                                                                                                                                                                                                                                                                                                                                        KeyG = 37

                                                                                                                                                                                                                                                                                                                                          member KeyH

                                                                                                                                                                                                                                                                                                                                          KeyH = 38

                                                                                                                                                                                                                                                                                                                                            member KeyI

                                                                                                                                                                                                                                                                                                                                            KeyI = 39

                                                                                                                                                                                                                                                                                                                                              member KeyJ

                                                                                                                                                                                                                                                                                                                                              KeyJ = 40

                                                                                                                                                                                                                                                                                                                                                member KeyK

                                                                                                                                                                                                                                                                                                                                                KeyK = 41

                                                                                                                                                                                                                                                                                                                                                  member KeyL

                                                                                                                                                                                                                                                                                                                                                  KeyL = 42

                                                                                                                                                                                                                                                                                                                                                    member KeyM

                                                                                                                                                                                                                                                                                                                                                    KeyM = 43

                                                                                                                                                                                                                                                                                                                                                      member KeyN

                                                                                                                                                                                                                                                                                                                                                      KeyN = 44

                                                                                                                                                                                                                                                                                                                                                        member KeyO

                                                                                                                                                                                                                                                                                                                                                        KeyO = 45

                                                                                                                                                                                                                                                                                                                                                          member KeyP

                                                                                                                                                                                                                                                                                                                                                          KeyP = 46

                                                                                                                                                                                                                                                                                                                                                            member KeyQ

                                                                                                                                                                                                                                                                                                                                                            KeyQ = 47

                                                                                                                                                                                                                                                                                                                                                              member KeyR

                                                                                                                                                                                                                                                                                                                                                              KeyR = 48

                                                                                                                                                                                                                                                                                                                                                                member KeyS

                                                                                                                                                                                                                                                                                                                                                                KeyS = 49

                                                                                                                                                                                                                                                                                                                                                                  member KeyT

                                                                                                                                                                                                                                                                                                                                                                  KeyT = 50

                                                                                                                                                                                                                                                                                                                                                                    member KeyU

                                                                                                                                                                                                                                                                                                                                                                    KeyU = 51

                                                                                                                                                                                                                                                                                                                                                                      member KeyV

                                                                                                                                                                                                                                                                                                                                                                      KeyV = 52

                                                                                                                                                                                                                                                                                                                                                                        member KeyW

                                                                                                                                                                                                                                                                                                                                                                        KeyW = 53

                                                                                                                                                                                                                                                                                                                                                                          member KeyX

                                                                                                                                                                                                                                                                                                                                                                          KeyX = 54

                                                                                                                                                                                                                                                                                                                                                                            member KeyY

                                                                                                                                                                                                                                                                                                                                                                            KeyY = 55

                                                                                                                                                                                                                                                                                                                                                                              member KeyZ

                                                                                                                                                                                                                                                                                                                                                                              KeyZ = 56

                                                                                                                                                                                                                                                                                                                                                                                member LaunchApp2

                                                                                                                                                                                                                                                                                                                                                                                LaunchApp2 = 130

                                                                                                                                                                                                                                                                                                                                                                                  member LaunchMail

                                                                                                                                                                                                                                                                                                                                                                                  LaunchMail = 129

                                                                                                                                                                                                                                                                                                                                                                                    member LaunchMediaPlayer

                                                                                                                                                                                                                                                                                                                                                                                    LaunchMediaPlayer = 128

                                                                                                                                                                                                                                                                                                                                                                                      member LeftArrow

                                                                                                                                                                                                                                                                                                                                                                                      LeftArrow = 15

                                                                                                                                                                                                                                                                                                                                                                                        member MAX_VALUE

                                                                                                                                                                                                                                                                                                                                                                                        MAX_VALUE = 132
                                                                                                                                                                                                                                                                                                                                                                                        • Placed last to cover the length of the enum. Please do not depend on this value!

                                                                                                                                                                                                                                                                                                                                                                                        member MediaPlayPause

                                                                                                                                                                                                                                                                                                                                                                                        MediaPlayPause = 127

                                                                                                                                                                                                                                                                                                                                                                                          member MediaStop

                                                                                                                                                                                                                                                                                                                                                                                          MediaStop = 126

                                                                                                                                                                                                                                                                                                                                                                                            member MediaTrackNext

                                                                                                                                                                                                                                                                                                                                                                                            MediaTrackNext = 124

                                                                                                                                                                                                                                                                                                                                                                                              member MediaTrackPrevious

                                                                                                                                                                                                                                                                                                                                                                                              MediaTrackPrevious = 125

                                                                                                                                                                                                                                                                                                                                                                                                member Meta

                                                                                                                                                                                                                                                                                                                                                                                                Meta = 57

                                                                                                                                                                                                                                                                                                                                                                                                  member Minus

                                                                                                                                                                                                                                                                                                                                                                                                  Minus = 88
                                                                                                                                                                                                                                                                                                                                                                                                  • For any country/region, the '-' key For the US standard keyboard, the '-_' key

                                                                                                                                                                                                                                                                                                                                                                                                  member NumLock

                                                                                                                                                                                                                                                                                                                                                                                                  NumLock = 83

                                                                                                                                                                                                                                                                                                                                                                                                    member NUMPAD_SEPARATOR

                                                                                                                                                                                                                                                                                                                                                                                                    NUMPAD_SEPARATOR = 110

                                                                                                                                                                                                                                                                                                                                                                                                      member Numpad0

                                                                                                                                                                                                                                                                                                                                                                                                      Numpad0 = 98

                                                                                                                                                                                                                                                                                                                                                                                                        member Numpad1

                                                                                                                                                                                                                                                                                                                                                                                                        Numpad1 = 99

                                                                                                                                                                                                                                                                                                                                                                                                          member Numpad2

                                                                                                                                                                                                                                                                                                                                                                                                          Numpad2 = 100

                                                                                                                                                                                                                                                                                                                                                                                                            member Numpad3

                                                                                                                                                                                                                                                                                                                                                                                                            Numpad3 = 101

                                                                                                                                                                                                                                                                                                                                                                                                              member Numpad4

                                                                                                                                                                                                                                                                                                                                                                                                              Numpad4 = 102

                                                                                                                                                                                                                                                                                                                                                                                                                member Numpad5

                                                                                                                                                                                                                                                                                                                                                                                                                Numpad5 = 103

                                                                                                                                                                                                                                                                                                                                                                                                                  member Numpad6

                                                                                                                                                                                                                                                                                                                                                                                                                  Numpad6 = 104

                                                                                                                                                                                                                                                                                                                                                                                                                    member Numpad7

                                                                                                                                                                                                                                                                                                                                                                                                                    Numpad7 = 105

                                                                                                                                                                                                                                                                                                                                                                                                                      member Numpad8

                                                                                                                                                                                                                                                                                                                                                                                                                      Numpad8 = 106

                                                                                                                                                                                                                                                                                                                                                                                                                        member Numpad9

                                                                                                                                                                                                                                                                                                                                                                                                                        Numpad9 = 107

                                                                                                                                                                                                                                                                                                                                                                                                                          member NumpadAdd

                                                                                                                                                                                                                                                                                                                                                                                                                          NumpadAdd = 109

                                                                                                                                                                                                                                                                                                                                                                                                                            member NumpadDecimal

                                                                                                                                                                                                                                                                                                                                                                                                                            NumpadDecimal = 112

                                                                                                                                                                                                                                                                                                                                                                                                                              member NumpadDivide

                                                                                                                                                                                                                                                                                                                                                                                                                              NumpadDivide = 113

                                                                                                                                                                                                                                                                                                                                                                                                                                member NumpadMultiply

                                                                                                                                                                                                                                                                                                                                                                                                                                NumpadMultiply = 108

                                                                                                                                                                                                                                                                                                                                                                                                                                  member NumpadSubtract

                                                                                                                                                                                                                                                                                                                                                                                                                                  NumpadSubtract = 111

                                                                                                                                                                                                                                                                                                                                                                                                                                    member OEM_8

                                                                                                                                                                                                                                                                                                                                                                                                                                    OEM_8 = 96
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Used for miscellaneous characters; it can vary by keyboard.

                                                                                                                                                                                                                                                                                                                                                                                                                                    member PageDown

                                                                                                                                                                                                                                                                                                                                                                                                                                    PageDown = 12

                                                                                                                                                                                                                                                                                                                                                                                                                                      member PageUp

                                                                                                                                                                                                                                                                                                                                                                                                                                      PageUp = 11

                                                                                                                                                                                                                                                                                                                                                                                                                                        member PauseBreak

                                                                                                                                                                                                                                                                                                                                                                                                                                        PauseBreak = 7

                                                                                                                                                                                                                                                                                                                                                                                                                                          member Period

                                                                                                                                                                                                                                                                                                                                                                                                                                          Period = 89
                                                                                                                                                                                                                                                                                                                                                                                                                                          • For any country/region, the '.' key For the US standard keyboard, the '.>' key

                                                                                                                                                                                                                                                                                                                                                                                                                                          member Quote

                                                                                                                                                                                                                                                                                                                                                                                                                                          Quote = 95
                                                                                                                                                                                                                                                                                                                                                                                                                                          • Used for miscellaneous characters; it can vary by keyboard. For the US standard keyboard, the ''"' key

                                                                                                                                                                                                                                                                                                                                                                                                                                          member RightArrow

                                                                                                                                                                                                                                                                                                                                                                                                                                          RightArrow = 17

                                                                                                                                                                                                                                                                                                                                                                                                                                            member ScrollLock

                                                                                                                                                                                                                                                                                                                                                                                                                                            ScrollLock = 84

                                                                                                                                                                                                                                                                                                                                                                                                                                              member Semicolon

                                                                                                                                                                                                                                                                                                                                                                                                                                              Semicolon = 85
                                                                                                                                                                                                                                                                                                                                                                                                                                              • Used for miscellaneous characters; it can vary by keyboard. For the US standard keyboard, the ';:' key

                                                                                                                                                                                                                                                                                                                                                                                                                                              member Shift

                                                                                                                                                                                                                                                                                                                                                                                                                                              Shift = 4

                                                                                                                                                                                                                                                                                                                                                                                                                                                member Slash

                                                                                                                                                                                                                                                                                                                                                                                                                                                Slash = 90
                                                                                                                                                                                                                                                                                                                                                                                                                                                • Used for miscellaneous characters; it can vary by keyboard. For the US standard keyboard, the '/?' key

                                                                                                                                                                                                                                                                                                                                                                                                                                                member Space

                                                                                                                                                                                                                                                                                                                                                                                                                                                Space = 10

                                                                                                                                                                                                                                                                                                                                                                                                                                                  member Tab

                                                                                                                                                                                                                                                                                                                                                                                                                                                  Tab = 2

                                                                                                                                                                                                                                                                                                                                                                                                                                                    member Unknown

                                                                                                                                                                                                                                                                                                                                                                                                                                                    Unknown = 0
                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Placed first to cover the 0 value of the enum.

                                                                                                                                                                                                                                                                                                                                                                                                                                                    member UpArrow

                                                                                                                                                                                                                                                                                                                                                                                                                                                    UpArrow = 16

                                                                                                                                                                                                                                                                                                                                                                                                                                                      enum MarkerSeverity

                                                                                                                                                                                                                                                                                                                                                                                                                                                      enum MarkerSeverity {
                                                                                                                                                                                                                                                                                                                                                                                                                                                      Hint = 1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                      Info = 2,
                                                                                                                                                                                                                                                                                                                                                                                                                                                      Warning = 4,
                                                                                                                                                                                                                                                                                                                                                                                                                                                      Error = 8,
                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                        member Error

                                                                                                                                                                                                                                                                                                                                                                                                                                                        Error = 8

                                                                                                                                                                                                                                                                                                                                                                                                                                                          member Hint

                                                                                                                                                                                                                                                                                                                                                                                                                                                          Hint = 1

                                                                                                                                                                                                                                                                                                                                                                                                                                                            member Info

                                                                                                                                                                                                                                                                                                                                                                                                                                                            Info = 2

                                                                                                                                                                                                                                                                                                                                                                                                                                                              member Warning

                                                                                                                                                                                                                                                                                                                                                                                                                                                              Warning = 4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                enum MarkerTag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                enum MarkerTag {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                Unnecessary = 1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                Deprecated = 2,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Deprecated = 2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member Unnecessary

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Unnecessary = 1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      enum SelectionDirection

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      enum SelectionDirection {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      LTR = 0,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      RTL = 1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • The direction of a selection.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member LTR

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      LTR = 0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • The selection starts above where it ends.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member RTL

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      RTL = 1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • The selection starts below where it ends.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Aliases

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Thenable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Thenable<T> = PromiseLike<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Namespaces

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        namespace editor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        namespace editor {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          variable EditorOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          const EditorOptions: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          acceptSuggestionOnCommitCharacter: IEditorOption<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          EditorOption.acceptSuggestionOnCommitCharacter,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          acceptSuggestionOnEnter: IEditorOption<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          EditorOption.acceptSuggestionOnEnter,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          'on' | 'off' | 'smart'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          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,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          'auto' | 'always' | 'never'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          autoClosingOvertype: IEditorOption<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          EditorOption.autoClosingOvertype,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          'auto' | 'always' | 'never'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          autoClosingQuotes: IEditorOption<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          EditorOption.autoClosingQuotes,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          'always' | 'languageDefined' | 'beforeWhitespace' | 'never'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          autoIndent: IEditorOption<EditorOption.autoIndent, EditorAutoIndentStrategy>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          automaticLayout: IEditorOption<EditorOption.automaticLayout, boolean>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          autoSurround: IEditorOption<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          EditorOption.autoSurround,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          'languageDefined' | 'never' | 'quotes' | 'brackets'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          bracketPairColorization: IEditorOption<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          EditorOption.bracketPairColorization,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Readonly<Required<IBracketPairColorizationOptions>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          bracketPairGuides: IEditorOption<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          EditorOption.guides,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Readonly<Required<IGuidesOptions>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          stickyTabStops: IEditorOption<EditorOption.stickyTabStops, boolean>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          codeLens: IEditorOption<EditorOption.codeLens, boolean>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          codeLensFontFamily: IEditorOption<EditorOption.codeLensFontFamily, string>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          codeLensFontSize: IEditorOption<EditorOption.codeLensFontSize, number>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          colorDecorators: IEditorOption<EditorOption.colorDecorators, boolean>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          colorDecoratorActivatedOn: IEditorOption<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          EditorOption.colorDecoratorsActivatedOn,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          'hover' | 'clickAndHover' | 'click'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          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,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          'on' | 'off' | 'explicit'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          cursorStyle: IEditorOption<EditorOption.cursorStyle, TextEditorCursorStyle>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          cursorSurroundingLines: IEditorOption<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          EditorOption.cursorSurroundingLines,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          cursorSurroundingLinesStyle: IEditorOption<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          EditorOption.cursorSurroundingLinesStyle,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          'default' | 'all'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          cursorWidth: IEditorOption<EditorOption.cursorWidth, number>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          disableLayerHinting: IEditorOption<EditorOption.disableLayerHinting, boolean>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          disableMonospaceOptimizations: IEditorOption<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          EditorOption.disableMonospaceOptimizations,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          domReadOnly: IEditorOption<EditorOption.domReadOnly, boolean>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          dragAndDrop: IEditorOption<EditorOption.dragAndDrop, boolean>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          emptySelectionClipboard: IEditorOption<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          EditorOption.emptySelectionClipboard,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          dropIntoEditor: IEditorOption<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          EditorOption.dropIntoEditor,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Readonly<Required<IDropIntoEditorOptions>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          stickyScroll: IEditorOption<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          EditorOption.stickyScroll,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Readonly<Required<IEditorStickyScrollOptions>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          experimentalWhitespaceRendering: IEditorOption<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          EditorOption.experimentalWhitespaceRendering,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          'off' | 'svg' | 'font'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          extraEditorClassName: IEditorOption<EditorOption.extraEditorClassName, string>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          fastScrollSensitivity: IEditorOption<EditorOption.fastScrollSensitivity, number>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          find: IEditorOption<EditorOption.find, Readonly<Required<IEditorFindOptions>>>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          fixedOverflowWidgets: IEditorOption<EditorOption.fixedOverflowWidgets, boolean>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          folding: IEditorOption<EditorOption.folding, boolean>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          foldingStrategy: IEditorOption<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          EditorOption.foldingStrategy,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          'auto' | 'indentation'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          foldingHighlight: IEditorOption<EditorOption.foldingHighlight, boolean>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          foldingImportsByDefault: IEditorOption<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          EditorOption.foldingImportsByDefault,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          foldingMaximumRegions: IEditorOption<EditorOption.foldingMaximumRegions, number>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          unfoldOnClickAfterEndOfLine: IEditorOption<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          EditorOption.unfoldOnClickAfterEndOfLine,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          fontFamily: IEditorOption<EditorOption.fontFamily, string>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          fontInfo: IEditorOption<EditorOption.fontInfo, FontInfo>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          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>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          gotoLocation: IEditorOption<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          EditorOption.gotoLocation,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Readonly<Required<IGotoLocationOptions>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          hideCursorInOverviewRuler: IEditorOption<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          EditorOption.hideCursorInOverviewRuler,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          hover: IEditorOption<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          EditorOption.hover,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Readonly<Required<IEditorHoverOptions>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          inDiffEditor: IEditorOption<EditorOption.inDiffEditor, boolean>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          letterSpacing: IEditorOption<EditorOption.letterSpacing, number>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          lightbulb: IEditorOption<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          EditorOption.lightbulb,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Readonly<Required<IEditorLightbulbOptions>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          lineDecorationsWidth: IEditorOption<EditorOption.lineDecorationsWidth, number>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          lineHeight: IEditorOption<EditorOption.lineHeight, number>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          lineNumbers: IEditorOption<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          EditorOption.lineNumbers,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          InternalEditorRenderLineNumbersOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          lineNumbersMinChars: IEditorOption<EditorOption.lineNumbersMinChars, number>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          linkedEditing: IEditorOption<EditorOption.linkedEditing, boolean>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          links: IEditorOption<EditorOption.links, boolean>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          matchBrackets: IEditorOption<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          EditorOption.matchBrackets,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          'always' | 'never' | 'near'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          minimap: IEditorOption<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          EditorOption.minimap,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Readonly<Required<IEditorMinimapOptions>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          mouseStyle: IEditorOption<EditorOption.mouseStyle, 'default' | 'text' | 'copy'>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          mouseWheelScrollSensitivity: IEditorOption<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          EditorOption.mouseWheelScrollSensitivity,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          mouseWheelZoom: IEditorOption<EditorOption.mouseWheelZoom, boolean>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          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,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          'off' | 'singleFile' | 'multiFile'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          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'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          placeholder: IEditorOption<EditorOption.placeholder, string>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          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'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          renderLineHighlight: IEditorOption<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          EditorOption.renderLineHighlight,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          'all' | 'line' | 'none' | 'gutter'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          renderLineHighlightOnlyWhenFocus: IEditorOption<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          EditorOption.renderLineHighlightOnlyWhenFocus,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          renderValidationDecorations: IEditorOption<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          EditorOption.renderValidationDecorations,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          'on' | 'off' | 'editable'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          renderWhitespace: IEditorOption<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          EditorOption.renderWhitespace,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          'all' | 'none' | 'boundary' | 'selection' | 'trailing'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          revealHorizontalRightPadding: IEditorOption<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          EditorOption.revealHorizontalRightPadding,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          roundedSelection: IEditorOption<EditorOption.roundedSelection, boolean>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          rulers: IEditorOption<EditorOption.rulers, {}>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          scrollbar: IEditorOption<EditorOption.scrollbar, InternalEditorScrollbarOptions>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          scrollBeyondLastColumn: IEditorOption<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          EditorOption.scrollBeyondLastColumn,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          scrollBeyondLastLine: IEditorOption<EditorOption.scrollBeyondLastLine, boolean>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          scrollPredominantAxis: IEditorOption<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          EditorOption.scrollPredominantAxis,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          selectionClipboard: IEditorOption<EditorOption.selectionClipboard, boolean>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          selectionHighlight: IEditorOption<EditorOption.selectionHighlight, boolean>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          selectOnLineNumbers: IEditorOption<EditorOption.selectOnLineNumbers, boolean>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          showFoldingControls: IEditorOption<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          EditorOption.showFoldingControls,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          'always' | 'never' | 'mouseover'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          showUnused: IEditorOption<EditorOption.showUnused, boolean>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          showDeprecated: IEditorOption<EditorOption.showDeprecated, boolean>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          inlayHints: IEditorOption<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          EditorOption.inlayHints,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Readonly<Required<IEditorInlayHintsOptions>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          snippetSuggestions: IEditorOption<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          EditorOption.snippetSuggestions,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          'none' | 'top' | 'bottom' | 'inline'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          smartSelect: IEditorOption<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          EditorOption.smartSelect,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Readonly<Required<ISmartSelectOptions>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          smoothScrolling: IEditorOption<EditorOption.smoothScrolling, boolean>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          stopRenderingLineAfter: IEditorOption<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          EditorOption.stopRenderingLineAfter,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          suggest: IEditorOption<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          EditorOption.suggest,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Readonly<Required<ISuggestOptions>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          inlineSuggest: IEditorOption<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          EditorOption.inlineSuggest,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Readonly<Required<IInlineSuggestOptions>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          inlineEdit: IEditorOption<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          EditorOption.inlineEdit,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Readonly<Required<IInlineEditOptions>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          inlineCompletionsAccessibilityVerbose: IEditorOption<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          EditorOption.inlineCompletionsAccessibilityVerbose,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          suggestFontSize: IEditorOption<EditorOption.suggestFontSize, number>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          suggestLineHeight: IEditorOption<EditorOption.suggestLineHeight, number>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          suggestOnTriggerCharacters: IEditorOption<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          EditorOption.suggestOnTriggerCharacters,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          suggestSelection: IEditorOption<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          EditorOption.suggestSelection,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          'first' | 'recentlyUsed' | 'recentlyUsedByPrefix'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          tabCompletion: IEditorOption<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          EditorOption.tabCompletion,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          'on' | 'off' | 'onlySnippets'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          tabIndex: IEditorOption<EditorOption.tabIndex, number>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          unicodeHighlight: IEditorOption<EditorOption.unicodeHighlighting, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          unusualLineTerminators: IEditorOption<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          EditorOption.unusualLineTerminators,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          'off' | 'auto' | 'prompt'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          useShadowDOM: IEditorOption<EditorOption.useShadowDOM, boolean>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          useTabStops: IEditorOption<EditorOption.useTabStops, boolean>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          wordBreak: IEditorOption<EditorOption.wordBreak, 'normal' | 'keepAll'>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          wordSegmenterLocales: IEditorOption<EditorOption.wordSegmenterLocales, {}>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          wordSeparators: IEditorOption<EditorOption.wordSeparators, string>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          wordWrap: IEditorOption<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          EditorOption.wordWrap,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          'wordWrapColumn' | 'on' | 'off' | 'bounded'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          wordWrapBreakAfterCharacters: IEditorOption<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          EditorOption.wordWrapBreakAfterCharacters,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          wordWrapBreakBeforeCharacters: IEditorOption<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          EditorOption.wordWrapBreakBeforeCharacters,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          wordWrapColumn: IEditorOption<EditorOption.wordWrapColumn, number>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          wordWrapOverride1: IEditorOption<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          EditorOption.wordWrapOverride1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          'on' | 'off' | 'inherit'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          wordWrapOverride2: IEditorOption<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          EditorOption.wordWrapOverride2,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          'on' | 'off' | 'inherit'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          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'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            variable EditorType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            const EditorType: { ICodeEditor: string; IDiffEditor: string };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • The type of the IEditor.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            variable EditorZoom

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            const EditorZoom: IEditorZoom;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function addCommand

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              addCommand: (descriptor: ICommandDescriptor) => IDisposable;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Add a command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function addEditorAction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              addEditorAction: (descriptor: IActionDescriptor) => IDisposable;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Add an action to all editors.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function addKeybindingRule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              addKeybindingRule: (rule: IKeybindingRule) => IDisposable;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Add a keybinding rule.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function addKeybindingRules

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              addKeybindingRules: (rules: IKeybindingRule[]) => IDisposable;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Add keybinding rules.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function colorize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              colorize: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              text: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              languageId: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              options: IColorizerOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<string>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Colorize text using language languageId.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function colorizeElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              colorizeElement: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              domNode: HTMLElement,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              options: IColorizerElementOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Colorize the contents of domNode using attribute data-lang.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function colorizeModelLine

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              colorizeModelLine: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              model: ITextModel,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              lineNumber: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              tabSize?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Colorize a line in a model.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function create

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              create: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              domElement: HTMLElement,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              options?: IStandaloneEditorConstructionOptions,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              override?: IEditorOverrideServices
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => IStandaloneCodeEditor;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Create a new editor under domElement. domElement should be empty (not contain other dom nodes). The editor will read the size of domElement.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function createDiffEditor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              createDiffEditor: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              domElement: HTMLElement,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              options?: IStandaloneDiffEditorConstructionOptions,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              override?: IEditorOverrideServices
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => IStandaloneDiffEditor;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Create a new diff editor under domElement. domElement should be empty (not contain other dom nodes). The editor will read the size of domElement.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function createModel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              createModel: (value: string, language?: string, uri?: Uri) => ITextModel;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Create a new editor model. You can specify the language that should be set for this model or let the language be inferred from the uri.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function createMultiFileDiffEditor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              createMultiFileDiffEditor: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              domElement: HTMLElement,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              override?: IEditorOverrideServices
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function createWebWorker

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                createWebWorker: <T extends object>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                opts: IWebWorkerOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => MonacoWebWorker<T>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Create a new web worker that has model syncing capabilities built in. Specify an AMD module to load that will create an object that will be proxied.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function defineTheme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                defineTheme: (themeName: string, themeData: IStandaloneThemeData) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Define a new theme or update an existing theme.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function getDiffEditors

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getDiffEditors: () => readonly IDiffEditor[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Get all the created diff editors.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function getEditors

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getEditors: () => readonly ICodeEditor[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Get all the created editors.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function getModel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getModel: (uri: Uri) => ITextModel | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Get the model that has uri if it exists.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function getModelMarkers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getModelMarkers: (filter: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                owner?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                resource?: Uri;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                take?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }) => IMarker[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Get markers for owner and/or resource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  list of markers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function getModels

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getModels: () => ITextModel[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Get all the created models.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function onDidChangeMarkers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onDidChangeMarkers: (listener: (e: readonly Uri[]) => void) => IDisposable;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Emitted when markers change for a model.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function onDidChangeModelLanguage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onDidChangeModelLanguage: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                listener: (e: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly model: ITextModel;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly oldLanguage: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => IDisposable;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Emitted when a different language is set to a model.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function onDidCreateDiffEditor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onDidCreateDiffEditor: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                listener: (diffEditor: IDiffEditor) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => IDisposable;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Emitted when an diff editor is created.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function onDidCreateEditor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onDidCreateEditor: (listener: (codeEditor: ICodeEditor) => void) => IDisposable;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Emitted when an editor is created. Creating a diff editor might cause this listener to be invoked with the two editors.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function onDidCreateModel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onDidCreateModel: (listener: (model: ITextModel) => void) => IDisposable;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Emitted when a model is created.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function onWillDisposeModel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onWillDisposeModel: (listener: (model: ITextModel) => void) => IDisposable;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Emitted right before a model is disposed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function registerCommand

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                registerCommand: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                id: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                handler: (accessor: any, ...args: any[]) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => IDisposable;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Register a command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function registerEditorOpener

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                registerEditorOpener: (opener: ICodeEditorOpener) => IDisposable;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • 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.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function registerLinkOpener

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                registerLinkOpener: (opener: ILinkOpener) => IDisposable;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • 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.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function remeasureFonts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                remeasureFonts: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Clears all cached font measurements and triggers re-measurement.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function removeAllMarkers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                removeAllMarkers: (owner: string) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Remove all markers of an owner.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function setModelLanguage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                setModelLanguage: (model: ITextModel, mimeTypeOrLanguageId: string) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Change the language for a model.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function setModelMarkers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                setModelMarkers: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                model: ITextModel,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                owner: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                markers: IMarkerData[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Set the markers for a model.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function setTheme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                setTheme: (themeName: string) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Switches to a theme.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function tokenize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                tokenize: (text: string, languageId: string) => Token[][];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Tokenize text using language languageId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class ApplyUpdateResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class ApplyUpdateResult<T> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor(newValue: {}, didChange: boolean);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property didChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly didChange: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property newValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly newValue: {};

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class BareFontInfo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class BareFontInfo {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property fontFamily

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly fontFamily: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property fontFeatureSettings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly fontFeatureSettings: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property fontSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly fontSize: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property fontVariationSettings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly fontVariationSettings: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property fontWeight

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly fontWeight: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property letterSpacing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly letterSpacing: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property lineHeight

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly lineHeight: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property pixelRatio

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly pixelRatio: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class ConfigurationChangedEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class ConfigurationChangedEvent {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • An event describing that the configuration of the editor has changed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method hasChanged

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          hasChanged: (id: EditorOption) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class FindMatch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class FindMatch {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property matches

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly matches: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property range

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly range: Range;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class FontInfo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class FontInfo extends BareFontInfo {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property canUseHalfwidthRightwardsArrow

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly canUseHalfwidthRightwardsArrow: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property isMonospace

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly isMonospace: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property isTrusted

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly isTrusted: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property maxDigitWidth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly maxDigitWidth: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property middotWidth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly middotWidth: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property spaceWidth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly spaceWidth: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property typicalFullwidthCharacterWidth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly typicalFullwidthCharacterWidth: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property typicalHalfwidthCharacterWidth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly typicalHalfwidthCharacterWidth: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property version

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly version: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property wsmiddotWidth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly wsmiddotWidth: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class TextModelResolvedOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class TextModelResolvedOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property bracketPairColorizationOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly bracketPairColorizationOptions: BracketPairColorizationOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property defaultEOL

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly defaultEOL: DefaultEndOfLine;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property indentSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly indentSize: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property insertSpaces

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly insertSpaces: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property originalIndentSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly originalIndentSize: number | 'tabSize';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property tabSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly tabSize: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property trimAutoWhitespace

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly trimAutoWhitespace: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface BracketPairColorizationOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface BracketPairColorizationOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property enabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          enabled: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property independentColorPoolPerBracketType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            independentColorPoolPerBracketType: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface EditorLayoutInfo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface EditorLayoutInfo {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • The internal layout details of the editor.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property contentLeft

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly contentLeft: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Left position for the content (actual text)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property contentWidth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly contentWidth: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • The width of the content (actual text)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property decorationsLeft

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly decorationsLeft: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Left position for the line decorations.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property decorationsWidth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly decorationsWidth: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • The width of the line decorations.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property glyphMarginDecorationLaneCount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly glyphMarginDecorationLaneCount: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • The number of decoration lanes to render in the glyph margin.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property glyphMarginLeft

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly glyphMarginLeft: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Left position for the glyph margin.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property glyphMarginWidth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly glyphMarginWidth: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • The width of the glyph margin.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property height

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly height: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Full editor height.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property horizontalScrollbarHeight

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly horizontalScrollbarHeight: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • The height of the horizontal scrollbar.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property isViewportWrapping

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly isViewportWrapping: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property isWordWrapMinified

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly isWordWrapMinified: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property lineNumbersLeft

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly lineNumbersLeft: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Left position for the line numbers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property lineNumbersWidth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly lineNumbersWidth: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • The width of the line numbers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property minimap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly minimap: EditorMinimapLayoutInfo;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Layout information for the minimap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property overviewRuler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly overviewRuler: OverviewRulerPosition;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • The position of the overview ruler.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property verticalScrollbarWidth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly verticalScrollbarWidth: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • The width of the vertical scrollbar.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property viewportColumn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly viewportColumn: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • The number of columns (of typical characters) fitting on a viewport line.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property width

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly width: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Full editor width.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property wrappingColumn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly wrappingColumn: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface EditorMinimapLayoutInfo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface EditorMinimapLayoutInfo {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The internal layout details of the editor.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property minimapCanvasInnerHeight

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly minimapCanvasInnerHeight: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property minimapCanvasInnerWidth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly minimapCanvasInnerWidth: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property minimapCanvasOuterHeight

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly minimapCanvasOuterHeight: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property minimapCanvasOuterWidth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly minimapCanvasOuterWidth: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property minimapHeightIsEditorHeight

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly minimapHeightIsEditorHeight: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property minimapIsSampling

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly minimapIsSampling: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property minimapLeft

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly minimapLeft: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property minimapLineHeight

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly minimapLineHeight: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property minimapScale

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly minimapScale: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property minimapWidth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly minimapWidth: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property renderMinimap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly renderMinimap: RenderMinimap;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface EditorWrappingInfo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface EditorWrappingInfo {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property isDominatedByLongLines

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly isDominatedByLongLines: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property isViewportWrapping

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly isViewportWrapping: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property isWordWrapMinified

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly isWordWrapMinified: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property wrappingColumn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly wrappingColumn: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface IActionDescriptor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface IActionDescriptor {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Description of an action contribution

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property contextMenuGroupId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    contextMenuGroupId?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Control if the action should show up in the context menu and where. The context menu of the editor has these default: navigation - The navigation group comes first in all cases. 1_modification - This group comes next and contains commands that modify your code. 9_cutcopypaste - The last default group with the basic editing commands. You can also create your own group. Defaults to null (don't show in context menu).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property contextMenuOrder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    contextMenuOrder?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Control the order in the context menu group.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    id: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • An unique identifier of the contributed action.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property keybindingContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    keybindingContext?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The keybinding rule (condition on top of precondition).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property keybindings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    keybindings?: number[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • An array of keybindings for the action.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property label

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    label: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • A label of the action that will be presented to the user.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property precondition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    precondition?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Precondition rule. The value should be a [context key expression](https://code.visualstudio.com/docs/getstarted/keybindings#_when-clause-contexts).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method run

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    run: (editor: ICodeEditor, ...args: any[]) => void | Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Method that will be executed when the action is triggered.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter editor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The editor instance is passed in as a convenience

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface IBaseMouseTarget

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface IBaseMouseTarget {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property element

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly element: HTMLElement | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • The target element

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property mouseColumn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly mouseColumn: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Desired mouse column (e.g. when position.column gets clamped to text length -- clicking after text on a line).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property position

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly position: Position | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • The 'approximate' editor position

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property range

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly range: Range | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • The 'approximate' editor range

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface IBracketPairColorizationOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface IBracketPairColorizationOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property enabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        enabled?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Enable or disable bracket pair colorization.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property independentColorPoolPerBracketType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        independentColorPoolPerBracketType?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Use independent color pool per bracket type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface IChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface IChange {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • A change

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property modifiedEndLineNumber

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly modifiedEndLineNumber: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property modifiedStartLineNumber

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly modifiedStartLineNumber: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property originalEndLineNumber

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly originalEndLineNumber: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property originalStartLineNumber

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly originalStartLineNumber: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ICharChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ICharChange extends IChange {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • A character level change.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property modifiedEndColumn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly modifiedEndColumn: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property modifiedStartColumn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly modifiedStartColumn: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property originalEndColumn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly originalEndColumn: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property originalStartColumn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly originalStartColumn: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ICodeEditor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ICodeEditor extends IEditor {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • A rich code editor.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onBeginUpdate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly onBeginUpdate: IEvent<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Some editor operations fire multiple events at once. To allow users to react to multiple events fired by a single operation, the editor fires a begin update before the operation and an end update after the operation. Whenever the editor fires onBeginUpdate, it will also fire onEndUpdate once the operation finishes. Note that not all operations are bracketed by onBeginUpdate and onEndUpdate.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onContextMenu

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly onContextMenu: IEvent<IEditorMouseEvent>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • An event emitted on a "contextmenu".

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onDidAttemptReadOnlyEdit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly onDidAttemptReadOnlyEdit: IEvent<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • An event emitted when editing failed because the editor is read-only.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onDidBlurEditorText

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly onDidBlurEditorText: IEvent<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • An event emitted when the text inside this editor lost focus (i.e. cursor stops blinking).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onDidBlurEditorWidget

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly onDidBlurEditorWidget: IEvent<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • An event emitted when the text inside this editor or an editor widget lost focus.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onDidChangeConfiguration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly onDidChangeConfiguration: IEvent<ConfigurationChangedEvent>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • An event emitted when the configuration of the editor has changed. (e.g. editor.updateOptions())

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onDidChangeCursorPosition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly onDidChangeCursorPosition: IEvent<ICursorPositionChangedEvent>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • An event emitted when the cursor position has changed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onDidChangeCursorSelection

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly onDidChangeCursorSelection: IEvent<ICursorSelectionChangedEvent>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • An event emitted when the cursor selection has changed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onDidChangeHiddenAreas

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly onDidChangeHiddenAreas: IEvent<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • An event emitted when hidden areas change in the editor (e.g. due to folding).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onDidChangeModel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly onDidChangeModel: IEvent<IModelChangedEvent>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • An event emitted when the model of this editor has changed (e.g. editor.setModel()).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onDidChangeModelContent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly onDidChangeModelContent: IEvent<IModelContentChangedEvent>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • An event emitted when the content of the current model has changed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onDidChangeModelDecorations

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly onDidChangeModelDecorations: IEvent<IModelDecorationsChangedEvent>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • An event emitted when the decorations of the current model have changed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onDidChangeModelLanguage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly onDidChangeModelLanguage: IEvent<IModelLanguageChangedEvent>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • An event emitted when the language of the current model has changed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onDidChangeModelLanguageConfiguration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly onDidChangeModelLanguageConfiguration: IEvent<IModelLanguageConfigurationChangedEvent>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • An event emitted when the language configuration of the current model has changed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onDidChangeModelOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly onDidChangeModelOptions: IEvent<IModelOptionsChangedEvent>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • An event emitted when the options of the current model has changed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onDidCompositionEnd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly onDidCompositionEnd: IEvent<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • An event emitted after composition has ended.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onDidCompositionStart

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly onDidCompositionStart: IEvent<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • An event emitted after composition has started.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onDidContentSizeChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly onDidContentSizeChange: IEvent<IContentSizeChangedEvent>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • An event emitted when the content width or content height in the editor has changed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onDidFocusEditorText

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly onDidFocusEditorText: IEvent<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • An event emitted when the text inside this editor gained focus (i.e. cursor starts blinking).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onDidFocusEditorWidget

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly onDidFocusEditorWidget: IEvent<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • An event emitted when the text inside this editor or an editor widget gained focus.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onDidLayoutChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly onDidLayoutChange: IEvent<EditorLayoutInfo>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • An event emitted when the layout of the editor has changed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onDidPaste

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly onDidPaste: IEvent<IPasteEvent>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • An event emitted when users paste text in the editor.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onDidScrollChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly onDidScrollChange: IEvent<IScrollEvent>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • An event emitted when the scroll in the editor has changed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onEndUpdate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly onEndUpdate: IEvent<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Fires after the editor completes the operation it fired onBeginUpdate for.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onKeyDown

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly onKeyDown: IEvent<IKeyboardEvent>