@codingame/monaco-vscode-api 1.79.11 → 1.79.13

package/dist/languageFeatures.d.ts

@@ -1,3707 +1,581 @@
-import { S as ServiceIdentifier, a as ServicesAccessor } from './instantiation.js';
-import { E as Event, a as IDisposable, C as CancellationToken, d as IWaitUntil } from './event.js';
-import { I as IJSONSchema } from './jsonSchema.js';
-import { q as ITextModel, P as Position, R as Range, S as Selection, v as IRange, E as EndOfLineSequence, u as IPosition, k as IMarkdownString, w as ISingleEditOperation, x as EditorAutoIndentStrategy, y as ITextEditorModel, z as ITextSnapshot, A as ITextBufferFactory } from './editorBrowser.js';
-import { S as Severity$1 } from './severity.js';
+import { S as ServiceIdentifier } from './instantiation.js';
+import { E as Event, a as IDisposable } from './event.js';
+import { a as ILanguageIdCodec, S as StandardTokenType, b as ColorId, c as ITokenPresentation, R as ReferenceProvider, D as DefinitionProvider, T as TypeDefinitionProvider, d as DeclarationProvider, e as ImplementationProvider, f as CodeActionProvider, g as DocumentPasteEditProvider, h as RenameProvider, i as DocumentFormattingEditProvider, j as DocumentRangeFormattingEditProvider, O as OnTypeFormattingEditProvider, k as DocumentSymbolProvider, l as InlayHintsProvider, m as DocumentColorProvider, n as CodeLensProvider, o as SignatureHelpProvider, H as HoverProvider, p as DocumentHighlightProvider, q as DocumentRangeSemanticTokensProvider, s as DocumentSemanticTokensProvider, t as SelectionRangeProvider, F as FoldingRangeProvider, L as LinkProvider, u as InlineCompletionsProvider, v as CompletionItemProvider, w as LinkedEditingRangeProvider, x as InlineValuesProvider, E as EvaluatableExpressionProvider, y as DocumentOnDropEditProvider } from './colorRegistry.js';
+import { r as EditorAutoIndentStrategy, j as ITextModel } from './editorBrowser.js';
+import { n as IRelativePattern } from './files.js';
 import { U as URI } from './uri.js';
-import { o as ISaveOptions, m as IRevertOptions, S as SaveReason, q as SaveSource } from './editor.js';
-import { V as VSBuffer, n as VSBufferReadable, o as VSBufferReadableStream, p as IFileStatWithMetadata, q as FileOperation, r as ReadableStream, s as IReadFileStreamOptions, t as IWriteFileOptions, u as IBaseFileStatWithMetadata, v as IFileReadLimits, w as IRelativePattern } from './files.js';
-import { a as IProgress, b as IProgressStep } from './progress.js';
-import { T as ThemeIcon } from './themables.js';
-import { E as ExtensionIdentifier } from './extensions.d2.ts';
 
-type TypeConstraint = string | Function;
-
-interface ICommandEvent {
-    commandId: string;
-    args: any[];
-}
-
-declare const ICommandService: ServiceIdentifier<ICommandService>;
-interface ICommandService {
-    readonly _serviceBrand: undefined;
-    onWillExecuteCommand: Event<ICommandEvent>;
-    onDidExecuteCommand: Event<ICommandEvent>;
-    executeCommand<T = any>(commandId: string, ...args: any[]): Promise<T | undefined>;
-}
-type ICommandsMap = Map<string, ICommand>;
-interface ICommandHandler {
-    (accessor: ServicesAccessor, ...args: any[]): void;
-}
-interface ICommand {
-    id: string;
-    handler: ICommandHandler;
-    description?: ICommandHandlerDescription | null;
-}
-interface ICommandHandlerDescription {
-    readonly description: string;
-    readonly args: ReadonlyArray<{
-        readonly name: string;
-        readonly isOptional?: boolean;
-        readonly description?: string;
-        readonly constraint?: TypeConstraint;
-        readonly schema?: IJSONSchema;
-    }>;
-    readonly returns?: string;
-}
-interface ICommandRegistry {
-    onDidRegisterCommand: Event<string>;
-    registerCommand(id: string, command: ICommandHandler): IDisposable;
-    registerCommand(command: ICommand): IDisposable;
-    registerCommandAlias(oldId: string, newId: string): IDisposable;
-    getCommand(id: string): ICommand | undefined;
-    getCommands(): ICommandsMap;
+interface IViewLineTokens {
+    equals(other: IViewLineTokens): boolean;
+    getCount(): number;
+    getForeground(tokenIndex: number): ColorId;
+    getEndOffset(tokenIndex: number): number;
+    getClassName(tokenIndex: number): string;
+    getInlineStyle(tokenIndex: number, colorMap: string[]): string;
+    getPresentation(tokenIndex: number): ITokenPresentation;
+    findTokenIndexAtOffset(offset: number): number;
+    getLineContent(): string;
+    getMetadata(tokenIndex: number): number;
+    getLanguageId(tokenIndex: number): string;
 }
-declare const CommandsRegistry: ICommandRegistry;
-
-declare class RGBA {
-    _rgbaBrand: void;
-    /**
-     * Red: integer in [0-255]
-     */
-    readonly r: number;
-    /**
-     * Green: integer in [0-255]
-     */
-    readonly g: number;
+declare class LineTokens implements IViewLineTokens {
+    _lineTokensBrand: void;
+    private readonly _tokens;
+    private readonly _tokensCount;
+    private readonly _text;
+    private readonly _languageIdCodec;
+    static defaultTokenMetadata: number;
+    static createEmpty(lineContent: string, decoder: ILanguageIdCodec): LineTokens;
+    constructor(tokens: Uint32Array, text: string, decoder: ILanguageIdCodec);
+    equals(other: IViewLineTokens): boolean;
+    slicedEquals(other: LineTokens, sliceFromTokenIndex: number, sliceTokenCount: number): boolean;
+    getLineContent(): string;
+    getCount(): number;
+    getStartOffset(tokenIndex: number): number;
+    getMetadata(tokenIndex: number): number;
+    getLanguageId(tokenIndex: number): string;
+    getStandardTokenType(tokenIndex: number): StandardTokenType;
+    getForeground(tokenIndex: number): ColorId;
+    getClassName(tokenIndex: number): string;
+    getInlineStyle(tokenIndex: number, colorMap: string[]): string;
+    getPresentation(tokenIndex: number): ITokenPresentation;
+    getEndOffset(tokenIndex: number): number;
     /**
-     * Blue: integer in [0-255]
+     * Find the token containing offset `offset`.
+     * @param offset The search offset
+     * @return The index of the token containing the offset.
      */
-    readonly b: number;
+    findTokenIndexAtOffset(offset: number): number;
+    inflate(): IViewLineTokens;
+    sliceAndInflate(startOffset: number, endOffset: number, deltaOffset: number): IViewLineTokens;
+    static convertToEndOffset(tokens: Uint32Array, lineTextLength: number): void;
+    static findIndexInTokensArray(tokens: Uint32Array, desiredIndex: number): number;
     /**
-     * Alpha: float in [0-1]
-     */
-    readonly a: number;
-    constructor(r: number, g: number, b: number, a?: number);
-    static equals(a: RGBA, b: RGBA): boolean;
+     * @pure
+     * @param insertTokens Must be sorted by offset.
+    */
+    withInserted(insertTokens: {
+        offset: number;
+        text: string;
+        tokenMetadata: number;
+    }[]): LineTokens;
 }
-declare class HSLA {
-    _hslaBrand: void;
-    /**
-     * Hue: integer in [0, 360]
-     */
-    readonly h: number;
+
+declare class ScopedLineTokens {
+    _scopedLineTokensBrand: void;
+    readonly languageId: string;
+    private readonly _actual;
+    private readonly _firstTokenIndex;
+    private readonly _lastTokenIndex;
+    readonly firstCharOffset: number;
+    private readonly _lastCharOffset;
+    constructor(actual: LineTokens, languageId: string, firstTokenIndex: number, lastTokenIndex: number, firstCharOffset: number, lastCharOffset: number);
+    getLineContent(): string;
+    getActualLineContentBefore(offset: number): string;
+    getTokenCount(): number;
+    findTokenIndexAtOffset(offset: number): number;
+    getStandardTokenType(tokenIndex: number): StandardTokenType;
+}
+
+/**
+ * Describes how comments for a language work.
+ */
+interface CommentRule {
     /**
-     * Saturation: float in [0, 1]
+     * The line comment token, like `// this is a comment`
      */
-    readonly s: number;
+    lineComment?: string | null;
     /**
-     * Luminosity: float in [0, 1]
+     * The block comment character pair, like `/* block comment *&#47;`
      */
-    readonly l: number;
+    blockComment?: CharacterPair | null;
+}
+/**
+ * The language configuration interface defines the contract between extensions and
+ * various editor features, like automatic bracket insertion, automatic indentation etc.
+ */
+interface LanguageConfiguration {
     /**
-     * Alpha: float in [0, 1]
+     * The language's comment settings.
      */
-    readonly a: number;
-    constructor(h: number, s: number, l: number, a: number);
-    static equals(a: HSLA, b: HSLA): boolean;
+    comments?: CommentRule;
     /**
-     * Converts an RGB color value to HSL. Conversion formula
-     * adapted from http://en.wikipedia.org/wiki/HSL_color_space.
-     * Assumes r, g, and b are contained in the set [0, 255] and
-     * returns h in the set [0, 360], s, and l in the set [0, 1].
+     * The language's brackets.
+     * This configuration implicitly affects pressing Enter around these brackets.
      */
-    static fromRGBA(rgba: RGBA): HSLA;
-    private static _hue2rgb;
+    brackets?: CharacterPair[];
     /**
-     * Converts an HSL color value to RGB. Conversion formula
-     * adapted from http://en.wikipedia.org/wiki/HSL_color_space.
-     * Assumes h in the set [0, 360] s, and l are contained in the set [0, 1] and
-     * returns r, g, and b in the set [0, 255].
+     * The language's word definition.
+     * If the language supports Unicode identifiers (e.g. JavaScript), it is preferable
+     * to provide a word definition that uses exclusion of known separators.
+     * e.g.: A regex that matches anything except known separators (and dot is allowed to occur in a floating point number):
+     *   /(-?\d*\.\d\w*)|([^\`\~\!\@\#\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g
      */
-    static toRGBA(hsla: HSLA): RGBA;
-}
-declare class HSVA {
-    _hsvaBrand: void;
+    wordPattern?: RegExp;
     /**
-     * Hue: integer in [0, 360]
+     * The language's indentation settings.
      */
-    readonly h: number;
+    indentationRules?: IndentationRule;
     /**
-     * Saturation: float in [0, 1]
+     * The language's rules to be evaluated when pressing Enter.
      */
-    readonly s: number;
+    onEnterRules?: OnEnterRule[];
     /**
-     * Value: float in [0, 1]
+     * The language's auto closing pairs. The 'close' character is automatically inserted with the
+     * 'open' character is typed. If not set, the configured brackets will be used.
      */
-    readonly v: number;
+    autoClosingPairs?: IAutoClosingPairConditional[];
     /**
-     * Alpha: float in [0, 1]
+     * The language's surrounding pairs. When the 'open' character is typed on a selection, the
+     * selected string is surrounded by the open and close characters. If not set, the autoclosing pairs
+     * settings will be used.
      */
-    readonly a: number;
-    constructor(h: number, s: number, v: number, a: number);
-    static equals(a: HSVA, b: HSVA): boolean;
-    static fromRGBA(rgba: RGBA): HSVA;
-    static toRGBA(hsva: HSVA): RGBA;
-}
-declare class Color {
-    static fromHex(hex: string): Color;
-    static equals(a: Color | null, b: Color | null): boolean;
-    readonly rgba: RGBA;
-    private _hsla?;
-    get hsla(): HSLA;
-    private _hsva?;
-    get hsva(): HSVA;
-    constructor(arg: RGBA | HSLA | HSVA);
-    equals(other: Color | null): boolean;
+    surroundingPairs?: IAutoClosingPair[];
     /**
-     * http://www.w3.org/TR/WCAG20/#relativeluminancedef
-     * Returns the number in the set [0, 1]. O => Darkest Black. 1 => Lightest white.
-     */
-    getRelativeLuminance(): number;
-    private static _relativeLuminanceForComponent;
+     * Defines a list of bracket pairs that are colorized depending on their nesting level.
+     * If not set, the configured brackets will be used.
+    */
+    colorizedBracketPairs?: CharacterPair[];
     /**
-     * http://www.w3.org/TR/WCAG20/#contrast-ratiodef
-     * Returns the contrast ration number in the set [1, 21].
+     * Defines what characters must be after the cursor for bracket or quote autoclosing to occur when using the \'languageDefined\' autoclosing setting.
+     *
+     * This is typically the set of characters which can not start an expression, such as whitespace, closing brackets, non-unary operators, etc.
      */
-    getContrastRatio(another: Color): number;
+    autoCloseBefore?: string;
     /**
-     *	http://24ways.org/2010/calculating-color-contrast
-     *  Return 'true' if darker color otherwise 'false'
+     * The language's folding rules.
      */
-    isDarker(): boolean;
+    folding?: FoldingRules;
     /**
-     *	http://24ways.org/2010/calculating-color-contrast
-     *  Return 'true' if lighter color otherwise 'false'
+     * **Deprecated** Do not use.
+     *
+     * @deprecated Will be replaced by a better API soon.
      */
-    isLighter(): boolean;
-    isLighterThan(another: Color): boolean;
-    isDarkerThan(another: Color): boolean;
-    lighten(factor: number): Color;
-    darken(factor: number): Color;
-    transparent(factor: number): Color;
-    isTransparent(): boolean;
-    isOpaque(): boolean;
-    opposite(): Color;
-    blend(c: Color): Color;
-    makeOpaque(opaqueBackground: Color): Color;
-    flatten(...backgrounds: Color[]): Color;
-    private static _flatten;
-    private _toString?;
-    toString(): string;
-    static getLighterColor(of: Color, relative: Color, factor?: number): Color;
-    static getDarkerColor(of: Color, relative: Color, factor?: number): Color;
-    static readonly white: Color;
-    static readonly black: Color;
-    static readonly red: Color;
-    static readonly blue: Color;
-    static readonly green: Color;
-    static readonly cyan: Color;
-    static readonly lightgrey: Color;
-    static readonly transparent: Color;
-}
-declare namespace Color {
-    namespace Format {
-        namespace CSS {
-            function formatRGB(color: Color): string;
-            function formatRGBA(color: Color): string;
-            function formatHSL(color: Color): string;
-            function formatHSLA(color: Color): string;
-            /**
-             * Formats the color as #RRGGBB
-             */
-            function formatHex(color: Color): string;
-            /**
-             * Formats the color as #RRGGBBAA
-             * If 'compact' is set, colors without transparancy will be printed as #RRGGBB
-             */
-            function formatHexA(color: Color, compact?: boolean): string;
-            /**
-             * The default format will use HEX if opaque and RGBA otherwise.
-             */
-            function format(color: Color): string;
-            /**
-             * Converts an Hex color value to a Color.
-             * returns r, g, and b are contained in the set [0, 255]
-             * @param hex string (#RGB, #RGBA, #RRGGBB or #RRGGBBAA).
-             */
-            function parseHex(hex: string): Color | null;
-        }
-    }
-}
-
-interface IDataTransferFile {
-    readonly id: string;
-    readonly name: string;
-    readonly uri?: URI;
-    data(): Promise<Uint8Array>;
-}
-interface IDataTransferItem {
-    asString(): Thenable<string>;
-    asFile(): IDataTransferFile | undefined;
-    value: any;
+    __electricCharacterSupport?: {
+        docComment?: IDocComment;
+    };
 }
-interface IReadonlyVSDataTransfer extends Iterable<readonly [string, IDataTransferItem]> {
+/**
+ * Describes indentation rules for a language.
+ */
+interface IndentationRule {
     /**
-     * Get the total number of entries in this data transfer.
+     * If a line matches this pattern, then all the lines after it should be unindented once (until another rule matches).
      */
-    get size(): number;
+    decreaseIndentPattern: RegExp;
     /**
-     * Check if this data transfer contains data for `mimeType`.
-     *
-     * This uses exact matching and does not support wildcards.
+     * If a line matches this pattern, then all the lines after it should be indented once (until another rule matches).
      */
-    has(mimeType: string): boolean;
+    increaseIndentPattern: RegExp;
     /**
-     * Check if this data transfer contains data matching `pattern`.
-     *
-     * This allows matching for wildcards, such as `image/*`.
-     *
-     * Use the special `files` mime type to match any file in the data transfer.
+     * If a line matches this pattern, then **only the next line** after it should be indented once.
      */
-    matches(pattern: string): boolean;
+    indentNextLinePattern?: RegExp | null;
     /**
-     * Retrieve the first entry for `mimeType`.
-     *
-     * Note that if you want to find all entries for a given mime type, use {@link IReadonlyVSDataTransfer.entries} instead.
+     * If a line matches this pattern, then its indentation should not be changed and it should not be evaluated against the other rules.
      */
-    get(mimeType: string): IDataTransferItem | undefined;
-}
-
-/**
- * Open ended enum at runtime
- */
-declare const enum LanguageId {
-    Null = 0,
-    PlainText = 1
-}
-/**
- * Open ended enum at runtime
- */
-declare const enum ColorId {
-    None = 0,
-    DefaultForeground = 1,
-    DefaultBackground = 2
-}
-/**
- * A standard token type.
- */
-declare const enum StandardTokenType {
-    Other = 0,
-    Comment = 1,
-    String = 2,
-    RegEx = 3
-}
-/**
- */
-interface ITokenPresentation {
-    foreground: ColorId;
-    italic: boolean;
-    bold: boolean;
-    underline: boolean;
-    strikethrough: boolean;
-}
-
-/**
- *
- */
-interface IRelatedInformation {
-    resource: URI;
-    message: string;
-    startLineNumber: number;
-    startColumn: number;
-    endLineNumber: number;
-    endColumn: number;
-}
-declare const enum MarkerTag {
-    Unnecessary = 1,
-    Deprecated = 2
-}
-declare enum MarkerSeverity {
-    Hint = 1,
-    Info = 2,
-    Warning = 4,
-    Error = 8
-}
-declare namespace MarkerSeverity {
-    function compare(a: MarkerSeverity, b: MarkerSeverity): number;
-    function toString(a: MarkerSeverity): string;
-    function fromSeverity(severity: Severity$1): MarkerSeverity;
-    function toSeverity(severity: MarkerSeverity): Severity$1;
-}
-interface IResourceMarker {
-    resource: URI;
-    marker: IMarkerData;
-}
-interface IMarker {
-    owner: string;
-    resource: URI;
-    severity: MarkerSeverity;
-    code?: string | {
-        value: string;
-        target: URI;
-    };
-    message: string;
-    source?: string;
-    startLineNumber: number;
-    startColumn: number;
-    endLineNumber: number;
-    endColumn: number;
-    modelVersionId?: number;
-    relatedInformation?: IRelatedInformation[];
-    tags?: MarkerTag[];
-}
-interface MarkerStatistics {
-    errors: number;
-    warnings: number;
-    infos: number;
-    unknowns: number;
-}
-/**
- * A structure defining a problem/warning/etc.
- */
-interface IMarkerData {
-    code?: string | {
-        value: string;
-        target: URI;
-    };
-    severity: MarkerSeverity;
-    message: string;
-    source?: string;
-    startLineNumber: number;
-    startColumn: number;
-    endLineNumber: number;
-    endColumn: number;
-    modelVersionId?: number;
-    relatedInformation?: IRelatedInformation[];
-    tags?: MarkerTag[];
-}
-declare namespace IMarkerData {
-    function makeKey(markerData: IMarkerData): string;
-    function makeKeyOptionalMessage(markerData: IMarkerData, useMessage: boolean): string;
-}
-
-interface IMarkerService {
-    readonly _serviceBrand: undefined;
-    getStatistics(): MarkerStatistics;
-    changeOne(owner: string, resource: URI, markers: IMarkerData[]): void;
-    changeAll(owner: string, data: IResourceMarker[]): void;
-    remove(owner: string, resources: URI[]): void;
-    read(filter?: {
-        owner?: string;
-        resource?: URI;
-        severities?: number;
-        take?: number;
-    }): IMarker[];
-    readonly onMarkerChanged: Event<readonly URI[]>;
+    unIndentedLinePattern?: RegExp | null;
 }
-declare const IMarkerService: ServiceIdentifier<IMarkerService>;
-
 /**
- * @internal
+ * Describes language specific folding markers such as '#region' and '#endregion'.
+ * The start and end regexes will be tested against the contents of all lines and must be designed efficiently:
+ * - the regex should start with '^'
+ * - regexp flags (i, g) are ignored
  */
-interface ILanguageIdCodec {
-    encodeLanguageId(languageId: string): LanguageId;
-    decodeLanguageId(languageId: LanguageId): string;
+interface FoldingMarkers {
+    start: RegExp;
+    end: RegExp;
 }
 /**
- * A provider result represents the values a provider, like the {@link HoverProvider},
- * may return. For once this is the actual result type `T`, like `Hover`, or a thenable that resolves
- * to that type `T`. In addition, `null` and `undefined` can be returned - either directly or from a
- * thenable.
- */
-type ProviderResult<T> = T | undefined | null | Thenable<T | undefined | null>;
-/**
- * A hover represents additional information for a symbol or word. Hovers are
- * rendered in a tooltip-like widget.
+ * Describes folding rules for a language.
  */
-interface Hover {
+interface FoldingRules {
     /**
-     * The contents of this hover.
+     * Used by the indentation based strategy to decide whether empty lines belong to the previous or the next block.
+     * A language adheres to the off-side rule if blocks in that language are expressed by their indentation.
+     * See [wikipedia](https://en.wikipedia.org/wiki/Off-side_rule) for more information.
+     * If not set, `false` is used and empty lines belong to the previous block.
      */
-    contents: IMarkdownString[];
+    offSide?: boolean;
     /**
-     * The range to which this hover applies. When missing, the
-     * editor will use the range at the current position or the
-     * current position itself.
+     * Region markers used by the language.
      */
-    range?: IRange;
+    markers?: FoldingMarkers;
 }
 /**
- * The hover provider interface defines the contract between extensions and
- * the [hover](https://code.visualstudio.com/docs/editor/intellisense)-feature.
+ * Describes a rule to be evaluated when pressing Enter.
  */
-interface HoverProvider {
+interface OnEnterRule {
     /**
-     * Provide a hover for the given position and document. Multiple hovers at the same
-     * position will be merged by the editor. A hover can have a range which defaults
-     * to the word range at the position when omitted.
+     * This rule will only execute if the text before the cursor matches this regular expression.
      */
-    provideHover(model: ITextModel, position: Position, token: CancellationToken): ProviderResult<Hover>;
-}
-/**
- * An evaluatable expression represents additional information for an expression in a document. Evaluatable expressions are
- * evaluated by a debugger or runtime and their result is rendered in a tooltip-like widget.
- * @internal
- */
-interface EvaluatableExpression {
+    beforeText: RegExp;
     /**
-     * The range to which this expression applies.
+     * This rule will only execute if the text after the cursor matches this regular expression.
      */
-    range: IRange;
+    afterText?: RegExp;
     /**
-     * This expression overrides the expression extracted from the range.
+     * This rule will only execute if the text above the this line matches this regular expression.
      */
-    expression?: string;
-}
-/**
- * The evaluatable expression provider interface defines the contract between extensions and
- * the debug hover.
- * @internal
- */
-interface EvaluatableExpressionProvider {
+    previousLineText?: RegExp;
     /**
-     * Provide a hover for the given position and document. Multiple hovers at the same
-     * position will be merged by the editor. A hover can have a range which defaults
-     * to the word range at the position when omitted.
+     * The action to execute.
      */
-    provideEvaluatableExpression(model: ITextModel, position: Position, token: CancellationToken): ProviderResult<EvaluatableExpression>;
+    action: EnterAction;
 }
 /**
- * A value-object that contains contextual information when requesting inline values from a InlineValuesProvider.
- * @internal
+ * Definition of documentation comments (e.g. Javadoc/JSdoc)
  */
-interface InlineValueContext {
-    frameId: number;
-    stoppedLocation: Range;
+interface IDocComment {
+    /**
+     * The string that starts a doc comment (e.g. '/**')
+     */
+    open: string;
+    /**
+     * The string that appears on the last line and closes the doc comment (e.g. ' * /').
+     */
+    close?: string;
 }
 /**
- * Provide inline value as text.
- * @internal
+ * A tuple of two characters, like a pair of
+ * opening and closing brackets.
  */
-interface InlineValueText {
-    type: 'text';
-    range: IRange;
-    text: string;
+type CharacterPair = [string, string];
+interface IAutoClosingPair {
+    open: string;
+    close: string;
 }
-/**
- * Provide inline value through a variable lookup.
- * @internal
- */
-interface InlineValueVariableLookup {
-    type: 'variable';
-    range: IRange;
-    variableName?: string;
-    caseSensitiveLookup: boolean;
+interface IAutoClosingPairConditional extends IAutoClosingPair {
+    notIn?: string[];
 }
 /**
- * Provide inline value through an expression evaluation.
- * @internal
+ * Describes what to do with the indentation when pressing Enter.
  */
-interface InlineValueExpression {
-    type: 'expression';
-    range: IRange;
-    expression?: string;
-}
-/**
- * Inline value information can be provided by different means:
- * - directly as a text value (class InlineValueText).
- * - as a name to use for a variable lookup (class InlineValueVariableLookup)
- * - as an evaluatable expression (class InlineValueEvaluatableExpression)
- * The InlineValue types combines all inline value types into one type.
- * @internal
- */
-type InlineValue = InlineValueText | InlineValueVariableLookup | InlineValueExpression;
-/**
- * The inline values provider interface defines the contract between extensions and
- * the debugger's inline values feature.
- * @internal
- */
-interface InlineValuesProvider {
+declare enum IndentAction {
     /**
+     * Insert new line and copy the previous line's indentation.
      */
-    onDidChangeInlineValues?: Event<void> | undefined;
+    None = 0,
     /**
-     * Provide the "inline values" for the given range and document. Multiple hovers at the same
-     * position will be merged by the editor. A hover can have a range which defaults
-     * to the word range at the position when omitted.
+     * Insert new line and indent once (relative to the previous line's indentation).
      */
-    provideInlineValues(model: ITextModel, viewPort: Range, context: InlineValueContext, token: CancellationToken): ProviderResult<InlineValue[]>;
-}
-declare const enum CompletionItemKind {
-    Method = 0,
-    Function = 1,
-    Constructor = 2,
-    Field = 3,
-    Variable = 4,
-    Class = 5,
-    Struct = 6,
-    Interface = 7,
-    Module = 8,
-    Property = 9,
-    Event = 10,
-    Operator = 11,
-    Unit = 12,
-    Value = 13,
-    Constant = 14,
-    Enum = 15,
-    EnumMember = 16,
-    Keyword = 17,
-    Text = 18,
-    Color = 19,
-    File = 20,
-    Reference = 21,
-    Customcolor = 22,
-    Folder = 23,
-    TypeParameter = 24,
-    User = 25,
-    Issue = 26,
-    Snippet = 27
-}
-interface CompletionItemLabel {
-    label: string;
-    detail?: string;
-    description?: string;
-}
-declare const enum CompletionItemTag {
-    Deprecated = 1
-}
-declare const enum CompletionItemInsertTextRule {
-    None = 0,
+    Indent = 1,
     /**
-     * Adjust whitespace/indentation of multiline insert texts to
-     * match the current line indentation.
+     * Insert two new lines:
+     *  - the first one indented which will hold the cursor
+     *  - the second one at the same indentation level
      */
-    KeepWhitespace = 1,
+    IndentOutdent = 2,
     /**
-     * `insertText` is a snippet.
+     * Insert new line and outdent once (relative to the previous line's indentation).
      */
-    InsertAsSnippet = 4
-}
-interface CompletionItemRanges {
-    insert: IRange;
-    replace: IRange;
+    Outdent = 3
 }
 /**
- * A completion item represents a text snippet that is
- * proposed to complete text that is being typed.
+ * Describes what to do when pressing Enter.
  */
-interface CompletionItem {
-    /**
-     * The label of this completion item. By default
-     * this is also the text that is inserted when selecting
-     * this completion.
-     */
-    label: string | CompletionItemLabel;
-    /**
-     * The kind of this completion item. Based on the kind
-     * an icon is chosen by the editor.
-     */
-    kind: CompletionItemKind;
-    /**
-     * A modifier to the `kind` which affect how the item
-     * is rendered, e.g. Deprecated is rendered with a strikeout
-     */
-    tags?: ReadonlyArray<CompletionItemTag>;
-    /**
-     * A human-readable string with additional information
-     * about this item, like type or symbol information.
-     */
-    detail?: string;
-    /**
-     * A human-readable string that represents a doc-comment.
-     */
-    documentation?: string | IMarkdownString;
-    /**
-     * A string that should be used when comparing this item
-     * with other items. When `falsy` the {@link CompletionItem.label label}
-     * is used.
-     */
-    sortText?: string;
-    /**
-     * A string that should be used when filtering a set of
-     * completion items. When `falsy` the {@link CompletionItem.label label}
-     * is used.
-     */
-    filterText?: string;
-    /**
-     * Select this item when showing. *Note* that only one completion item can be selected and
-     * that the editor decides which item that is. The rule is that the *first* item of those
-     * that match best is selected.
-     */
-    preselect?: boolean;
+interface EnterAction {
     /**
-     * A string or snippet that should be inserted in a document when selecting
-     * this completion.
+     * Describe what to do with the indentation.
      */
-    insertText: string;
+    indentAction: IndentAction;
     /**
-     * Additional rules (as bitmask) that should be applied when inserting
-     * this completion.
+     * Describes text to be appended after the new line and after the indentation.
      */
-    insertTextRules?: CompletionItemInsertTextRule;
+    appendText?: string;
     /**
-     * A range of text that should be replaced by this completion item.
-     *
-     * Defaults to a range from the start of the {@link TextDocument.getWordRangeAtPosition current word} to the
-     * current position.
-     *
-     * *Note:* The range must be a {@link Range.isSingleLine single line} and it must
-     * {@link Range.contains contain} the position at which completion has been {@link CompletionItemProvider.provideCompletionItems requested}.
+     * Describes the number of characters to remove from the new line's indentation.
      */
-    range: IRange | CompletionItemRanges;
+    removeText?: number;
+}
+/**
+ * @internal
+ */
+declare class StandardAutoClosingPairConditional {
+    readonly open: string;
+    readonly close: string;
+    private readonly _inString;
+    private readonly _inComment;
+    private readonly _inRegEx;
+    private _neutralCharacter;
+    private _neutralCharacterSearched;
+    constructor(source: IAutoClosingPairConditional);
+    isOK(standardToken: StandardTokenType): boolean;
+    shouldAutoClose(context: ScopedLineTokens, column: number): boolean;
+    private _findNeutralCharacterInRange;
     /**
-     * An optional set of characters that when pressed while this completion is active will accept it first and
-     * then type that character. *Note* that all commit characters should have `length=1` and that superfluous
-     * characters will be ignored.
+     * Find a character in the range [0-9a-zA-Z] that does not appear in the open or close
      */
-    commitCharacters?: string[];
+    findNeutralCharacter(): string | null;
+}
+/**
+ * @internal
+ */
+declare class AutoClosingPairs {
+    /** Key is first character of open */
+    readonly autoClosingPairsOpenByStart: Map<string, StandardAutoClosingPairConditional[]>;
+    /** Key is last character of open */
+    readonly autoClosingPairsOpenByEnd: Map<string, StandardAutoClosingPairConditional[]>;
+    /** Key is first character of close */
+    readonly autoClosingPairsCloseByStart: Map<string, StandardAutoClosingPairConditional[]>;
+    /** Key is last character of close */
+    readonly autoClosingPairsCloseByEnd: Map<string, StandardAutoClosingPairConditional[]>;
+    /** Key is close. Only has pairs that are a single character */
+    readonly autoClosingPairsCloseSingleChar: Map<string, StandardAutoClosingPairConditional[]>;
+    constructor(autoClosingPairs: StandardAutoClosingPairConditional[]);
+}
+
+/**
+ * Captures all bracket related configurations for a single language.
+ * Immutable.
+*/
+declare class LanguageBracketsConfiguration {
+    readonly languageId: string;
+    private readonly _openingBrackets;
+    private readonly _closingBrackets;
+    constructor(languageId: string, config: LanguageConfiguration);
     /**
-     * An optional array of additional text edits that are applied when
-     * selecting this completion. Edits must not overlap with the main edit
-     * nor with themselves.
-     */
-    additionalTextEdits?: ISingleEditOperation[];
+     * No two brackets have the same bracket text.
+    */
+    get openingBrackets(): readonly OpeningBracketKind[];
     /**
-     * A command that should be run upon acceptance of this item.
-     */
-    command?: Command;
+     * No two brackets have the same bracket text.
+    */
+    get closingBrackets(): readonly ClosingBracketKind[];
+    getOpeningBracketInfo(bracketText: string): OpeningBracketKind | undefined;
+    getClosingBracketInfo(bracketText: string): ClosingBracketKind | undefined;
+    getBracketInfo(bracketText: string): BracketKind | undefined;
+}
+type BracketKind = OpeningBracketKind | ClosingBracketKind;
+declare class BracketKindBase {
+    protected readonly config: LanguageBracketsConfiguration;
+    readonly bracketText: string;
+    constructor(config: LanguageBracketsConfiguration, bracketText: string);
+    get languageId(): string;
+}
+declare class OpeningBracketKind extends BracketKindBase {
+    readonly openedBrackets: ReadonlySet<ClosingBracketKind>;
+    readonly isOpeningBracket = true;
+    constructor(config: LanguageBracketsConfiguration, bracketText: string, openedBrackets: ReadonlySet<ClosingBracketKind>);
+}
+declare class ClosingBracketKind extends BracketKindBase {
     /**
-     * @internal
-     */
-    extensionId?: ExtensionIdentifier;
+     * Non empty array of all opening brackets this bracket closes.
+    */
+    readonly openingBrackets: ReadonlySet<OpeningBracketKind>;
+    private readonly openingColorizedBrackets;
+    readonly isOpeningBracket = false;
+    constructor(config: LanguageBracketsConfiguration, bracketText: string, 
     /**
-     * @internal
-     */
-    _id?: [number, number];
-}
-interface CompletionList {
-    suggestions: CompletionItem[];
-    incomplete?: boolean;
-    dispose?(): void;
+     * Non empty array of all opening brackets this bracket closes.
+    */
+    openingBrackets: ReadonlySet<OpeningBracketKind>, openingColorizedBrackets: ReadonlySet<OpeningBracketKind>);
     /**
-     * @internal
-     */
-    duration?: number;
+     * Checks if this bracket closes the given other bracket.
+     * If the bracket infos come from different configurations, this method will return false.
+    */
+    closes(other: OpeningBracketKind): boolean;
+    closesColorized(other: OpeningBracketKind): boolean;
+    getOpeningBrackets(): readonly OpeningBracketKind[];
 }
-/**
- * How a suggest provider was triggered.
- */
-declare const enum CompletionTriggerKind {
-    Invoke = 0,
-    TriggerCharacter = 1,
-    TriggerForIncompleteCompletions = 2
+
+declare class CharacterPairSupport {
+    static readonly DEFAULT_AUTOCLOSE_BEFORE_LANGUAGE_DEFINED_QUOTES = ";:.,=}])> \n\t";
+    static readonly DEFAULT_AUTOCLOSE_BEFORE_LANGUAGE_DEFINED_BRACKETS = "'\"`;:.,=}])> \n\t";
+    static readonly DEFAULT_AUTOCLOSE_BEFORE_WHITESPACE = " \n\t";
+    private readonly _autoClosingPairs;
+    private readonly _surroundingPairs;
+    private readonly _autoCloseBeforeForQuotes;
+    private readonly _autoCloseBeforeForBrackets;
+    constructor(config: LanguageConfiguration);
+    getAutoClosingPairs(): StandardAutoClosingPairConditional[];
+    getAutoCloseBeforeSet(forQuotes: boolean): string;
+    getSurroundingPairs(): IAutoClosingPair[];
 }
+
 /**
- * Contains additional information about the context in which
- * {@link CompletionItemProvider.provideCompletionItems completion provider} is triggered.
+ * Represents a grouping of colliding bracket pairs.
+ *
+ * Most of the times this contains a single bracket pair,
+ * but sometimes this contains multiple bracket pairs in cases
+ * where the same string appears as a closing bracket for multiple
+ * bracket pairs, or the same string appears an opening bracket for
+ * multiple bracket pairs.
+ *
+ * e.g. of a group containing a single pair:
+ *   open: ['{'], close: ['}']
+ *
+ * e.g. of a group containing multiple pairs:
+ *   open: ['if', 'for'], close: ['end', 'end']
  */
-interface CompletionContext {
+declare class RichEditBracket {
+    _richEditBracketBrand: void;
+    readonly languageId: string;
     /**
-     * How the completion was triggered.
+     * A 0-based consecutive unique identifier for this bracket pair.
+     * If a language has 5 bracket pairs, out of which 2 are grouped together,
+     * it is expected that the `index` goes from 0 to 4.
      */
-    triggerKind: CompletionTriggerKind;
+    readonly index: number;
     /**
-     * Character that triggered the completion item provider.
+     * The open sequence for each bracket pair contained in this group.
+     *
+     * The open sequence at a specific index corresponds to the
+     * closing sequence at the same index.
      *
-     * `undefined` if provider was not triggered by a character.
+     * [ open[i], closed[i] ] represent a bracket pair.
      */
-    triggerCharacter?: string;
-}
-/**
- * The completion item provider interface defines the contract between extensions and
- * the [IntelliSense](https://code.visualstudio.com/docs/editor/intellisense).
- *
- * When computing *complete* completion items is expensive, providers can optionally implement
- * the `resolveCompletionItem`-function. In that case it is enough to return completion
- * items with a {@link CompletionItem.label label} from the
- * {@link CompletionItemProvider.provideCompletionItems provideCompletionItems}-function. Subsequently,
- * when a completion item is shown in the UI and gains focus this provider is asked to resolve
- * the item, like adding {@link CompletionItem.documentation doc-comment} or {@link CompletionItem.detail details}.
- */
-interface CompletionItemProvider {
+    readonly open: string[];
     /**
-     * @internal
+     * The close sequence for each bracket pair contained in this group.
+     *
+     * The close sequence at a specific index corresponds to the
+     * opening sequence at the same index.
+     *
+     * [ open[i], closed[i] ] represent a bracket pair.
      */
-    _debugDisplayName?: string;
-    triggerCharacters?: string[];
+    readonly close: string[];
     /**
-     * Provide completion items for the given position and document.
+     * A regular expression that is useful to search for this bracket pair group in a string.
+     *
+     * This regular expression is built in a way that it is aware of the other bracket
+     * pairs defined for the language, so it might match brackets from other groups.
+     *
+     * See the fine details in `getRegexForBracketPair`.
      */
-    provideCompletionItems(model: ITextModel, position: Position, context: CompletionContext, token: CancellationToken): ProviderResult<CompletionList>;
+    readonly forwardRegex: RegExp;
     /**
-     * Given a completion item fill in more data, like {@link CompletionItem.documentation doc-comment}
-     * or {@link CompletionItem.detail details}.
+     * A regular expression that is useful to search for this bracket pair group in a string backwards.
+     *
+     * This regular expression is built in a way that it is aware of the other bracket
+     * pairs defined for the language, so it might match brackets from other groups.
      *
-     * The editor will only resolve a completion item once.
+     * See the fine defails in `getReversedRegexForBracketPair`.
      */
-    resolveCompletionItem?(item: CompletionItem, token: CancellationToken): ProviderResult<CompletionItem>;
-}
-/**
- * How an {@link InlineCompletionsProvider inline completion provider} was triggered.
- */
-declare enum InlineCompletionTriggerKind {
+    readonly reversedRegex: RegExp;
+    private readonly _openSet;
+    private readonly _closeSet;
+    constructor(languageId: string, index: number, open: string[], close: string[], forwardRegex: RegExp, reversedRegex: RegExp);
     /**
-     * Completion was triggered automatically while editing.
-     * It is sufficient to return a single completion item in this case.
+     * Check if the provided `text` is an open bracket in this group.
      */
-    Automatic = 0,
+    isOpen(text: string): boolean;
     /**
-     * Completion was triggered explicitly by a user gesture.
-     * Return multiple completion items to enable cycling through them.
+     * Check if the provided `text` is a close bracket in this group.
      */
-    Explicit = 1
+    isClose(text: string): boolean;
+    private static _toSet;
 }
-interface InlineCompletionContext {
+declare class RichEditBrackets {
+    _richEditBracketsBrand: void;
     /**
-     * How the completion was triggered.
+     * All groups of brackets defined for this language.
      */
-    readonly triggerKind: InlineCompletionTriggerKind;
-    readonly selectedSuggestionInfo: SelectedSuggestionInfo | undefined;
-}
-declare class SelectedSuggestionInfo {
-    readonly range: IRange;
-    readonly text: string;
-    readonly completionKind: CompletionItemKind;
-    readonly isSnippetText: boolean;
-    constructor(range: IRange, text: string, completionKind: CompletionItemKind, isSnippetText: boolean);
-    equals(other: SelectedSuggestionInfo): boolean;
-}
-interface InlineCompletion {
+    readonly brackets: RichEditBracket[];
     /**
-     * The text to insert.
-     * If the text contains a line break, the range must end at the end of a line.
-     * If existing text should be replaced, the existing text must be a prefix of the text to insert.
+     * A regular expression that is useful to search for all bracket pairs in a string.
      *
-     * The text can also be a snippet. In that case, a preview with default parameters is shown.
-     * When accepting the suggestion, the full snippet is inserted.
-    */
-    readonly insertText: string | {
-        snippet: string;
-    };
-    /**
-     * A text that is used to decide if this inline completion should be shown.
-     * An inline completion is shown if the text to replace is a subword of the filter text.
+     * See the fine details in `getRegexForBrackets`.
      */
-    readonly filterText?: string;
+    readonly forwardRegex: RegExp;
     /**
-     * An optional array of additional text edits that are applied when
-     * selecting this completion. Edits must not overlap with the main edit
-     * nor with themselves.
+     * A regular expression that is useful to search for all bracket pairs in a string backwards.
+     *
+     * See the fine details in `getReversedRegexForBrackets`.
      */
-    readonly additionalTextEdits?: ISingleEditOperation[];
-    /**
-     * The range to replace.
-     * Must begin and end on the same line.
-    */
-    readonly range?: IRange;
-    readonly command?: Command;
-    /**
-     * If set to `true`, unopened closing brackets are removed and unclosed opening brackets are closed.
-     * Defaults to `false`.
-    */
-    readonly completeBracketPairs?: boolean;
-}
-interface InlineCompletions<TItem extends InlineCompletion = InlineCompletion> {
-    readonly items: readonly TItem[];
+    readonly reversedRegex: RegExp;
     /**
-     * A list of commands associated with the inline completions of this list.
+     * The length (i.e. str.length) for the longest bracket pair.
      */
-    readonly commands?: Command[];
-    readonly suppressSuggestions?: boolean | undefined;
+    readonly maxBracketLength: number;
     /**
-     * When set and the user types a suggestion without derivating from it, the inline suggestion is not updated.
+     * A map useful for decoding a regex match and finding which bracket group was matched.
      */
-    readonly enableForwardStability?: boolean | undefined;
-}
-interface InlineCompletionsProvider<T extends InlineCompletions = InlineCompletions> {
-    provideInlineCompletions(model: ITextModel, position: Position, context: InlineCompletionContext, token: CancellationToken): ProviderResult<T>;
-    /**
-     * Will be called when an item is shown.
-     * @param updatedInsertText Is useful to understand bracket completion.
-    */
-    handleItemDidShow?(completions: T, item: T['items'][number], updatedInsertText: string): void;
+    readonly textIsBracket: {
+        [text: string]: RichEditBracket;
+    };
     /**
-     * Will be called when an item is partially accepted.
+     * A set useful for decoding if a regex match is the open bracket of a bracket pair.
      */
-    handlePartialAccept?(completions: T, item: T['items'][number], acceptedCharacters: number): void;
-    /**
-     * Will be called when a completions list is no longer in use and can be garbage-collected.
-    */
-    freeInlineCompletions(completions: T): void;
-}
-interface CodeAction {
-    title: string;
-    command?: Command;
-    edit?: WorkspaceEdit;
-    diagnostics?: IMarkerData[];
-    kind?: string;
-    isPreferred?: boolean;
-    disabled?: string;
-}
-declare const enum CodeActionTriggerType {
-    Invoke = 1,
-    Auto = 2
+    readonly textIsOpenBracket: {
+        [text: string]: boolean;
+    };
+    constructor(languageId: string, _brackets: readonly CharacterPair[]);
 }
+
 /**
+ * Interface used to support electric characters
  * @internal
  */
-interface CodeActionContext {
-    only?: string;
-    trigger: CodeActionTriggerType;
-}
-interface CodeActionList extends IDisposable {
-    readonly actions: ReadonlyArray<CodeAction>;
-}
-/**
- * The code action interface defines the contract between extensions and
- * the [light bulb](https://code.visualstudio.com/docs/editor/editingevolved#_code-action) feature.
- * @internal
- */
-interface CodeActionProvider {
-    displayName?: string;
-    /**
-     * Provide commands for the given document and range.
-     */
-    provideCodeActions(model: ITextModel, range: Range | Selection, context: CodeActionContext, token: CancellationToken): ProviderResult<CodeActionList>;
-    /**
-     * Given a code action fill in the edit. Will only invoked when missing.
-     */
-    resolveCodeAction?(codeAction: CodeAction, token: CancellationToken): ProviderResult<CodeAction>;
-    /**
-     * Optional list of CodeActionKinds that this provider returns.
-     */
-    readonly providedCodeActionKinds?: ReadonlyArray<string>;
-    readonly documentation?: ReadonlyArray<{
-        readonly kind: string;
-        readonly command: Command;
-    }>;
-    /**
-     * @internal
-     */
-    _getAdditionalMenuItems?(context: CodeActionContext, actions: readonly CodeAction[]): Command[];
-}
-/**
- * @internal
- */
-interface DocumentPasteEdit {
-    readonly id: string;
-    readonly label: string;
-    readonly detail: string;
-    readonly priority: number;
-    insertText: string | {
-        readonly snippet: string;
-    };
-    additionalEdit?: WorkspaceEdit;
-}
-/**
- * @internal
- */
-interface DocumentPasteEditProvider {
-    readonly id?: string;
-    readonly copyMimeTypes?: readonly string[];
-    readonly pasteMimeTypes?: readonly string[];
-    prepareDocumentPaste?(model: ITextModel, ranges: readonly IRange[], dataTransfer: IReadonlyVSDataTransfer, token: CancellationToken): Promise<undefined | IReadonlyVSDataTransfer>;
-    provideDocumentPasteEdits?(model: ITextModel, ranges: readonly IRange[], dataTransfer: IReadonlyVSDataTransfer, token: CancellationToken): Promise<DocumentPasteEdit | undefined>;
-}
-/**
- * Represents a parameter of a callable-signature. A parameter can
- * have a label and a doc-comment.
- */
-interface ParameterInformation {
-    /**
-     * The label of this signature. Will be shown in
-     * the UI.
-     */
-    label: string | [number, number];
-    /**
-     * The human-readable doc-comment of this signature. Will be shown
-     * in the UI but can be omitted.
-     */
-    documentation?: string | IMarkdownString;
-}
-/**
- * Represents the signature of something callable. A signature
- * can have a label, like a function-name, a doc-comment, and
- * a set of parameters.
- */
-interface SignatureInformation {
-    /**
-     * The label of this signature. Will be shown in
-     * the UI.
-     */
-    label: string;
-    /**
-     * The human-readable doc-comment of this signature. Will be shown
-     * in the UI but can be omitted.
-     */
-    documentation?: string | IMarkdownString;
-    /**
-     * The parameters of this signature.
-     */
-    parameters: ParameterInformation[];
-    /**
-     * Index of the active parameter.
-     *
-     * If provided, this is used in place of `SignatureHelp.activeSignature`.
-     */
-    activeParameter?: number;
-}
-/**
- * Signature help represents the signature of something
- * callable. There can be multiple signatures but only one
- * active and only one active parameter.
- */
-interface SignatureHelp {
-    /**
-     * One or more signatures.
-     */
-    signatures: SignatureInformation[];
-    /**
-     * The active signature.
-     */
-    activeSignature: number;
-    /**
-     * The active parameter of the active signature.
-     */
-    activeParameter: number;
-}
-interface SignatureHelpResult extends IDisposable {
-    value: SignatureHelp;
-}
-declare enum SignatureHelpTriggerKind {
-    Invoke = 1,
-    TriggerCharacter = 2,
-    ContentChange = 3
-}
-interface SignatureHelpContext {
-    readonly triggerKind: SignatureHelpTriggerKind;
-    readonly triggerCharacter?: string;
-    readonly isRetrigger: boolean;
-    readonly activeSignatureHelp?: SignatureHelp;
-}
-/**
- * The signature help provider interface defines the contract between extensions and
- * the [parameter hints](https://code.visualstudio.com/docs/editor/intellisense)-feature.
- */
-interface SignatureHelpProvider {
-    readonly signatureHelpTriggerCharacters?: ReadonlyArray<string>;
-    readonly signatureHelpRetriggerCharacters?: ReadonlyArray<string>;
-    /**
-     * Provide help for the signature at the given position and document.
-     */
-    provideSignatureHelp(model: ITextModel, position: Position, token: CancellationToken, context: SignatureHelpContext): ProviderResult<SignatureHelpResult>;
-}
-/**
- * A document highlight kind.
- */
-declare enum DocumentHighlightKind {
-    /**
-     * A textual occurrence.
-     */
-    Text = 0,
-    /**
-     * Read-access of a symbol, like reading a variable.
-     */
-    Read = 1,
-    /**
-     * Write-access of a symbol, like writing to a variable.
-     */
-    Write = 2
-}
-/**
- * A document highlight is a range inside a text document which deserves
- * special attention. Usually a document highlight is visualized by changing
- * the background color of its range.
- */
-interface DocumentHighlight {
-    /**
-     * The range this highlight applies to.
-     */
-    range: IRange;
-    /**
-     * The highlight kind, default is {@link DocumentHighlightKind.Text text}.
-     */
-    kind?: DocumentHighlightKind;
-}
-/**
- * The document highlight provider interface defines the contract between extensions and
- * the word-highlight-feature.
- */
-interface DocumentHighlightProvider {
-    /**
-     * Provide a set of document highlights, like all occurrences of a variable or
-     * all exit-points of a function.
-     */
-    provideDocumentHighlights(model: ITextModel, position: Position, token: CancellationToken): ProviderResult<DocumentHighlight[]>;
-}
-/**
- * The linked editing range provider interface defines the contract between extensions and
- * the linked editing feature.
- */
-interface LinkedEditingRangeProvider {
-    /**
-     * Provide a list of ranges that can be edited together.
-     */
-    provideLinkedEditingRanges(model: ITextModel, position: Position, token: CancellationToken): ProviderResult<LinkedEditingRanges>;
-}
-/**
- * Represents a list of ranges that can be edited together along with a word pattern to describe valid contents.
- */
-interface LinkedEditingRanges {
-    /**
-     * A list of ranges that can be edited together. The ranges must have
-     * identical length and text content. The ranges cannot overlap
-     */
-    ranges: IRange[];
-    /**
-     * An optional word pattern that describes valid contents for the given ranges.
-     * If no pattern is provided, the language configuration's word pattern will be used.
-     */
-    wordPattern?: RegExp;
-}
-/**
- * Value-object that contains additional information when
- * requesting references.
- */
-interface ReferenceContext {
-    /**
-     * Include the declaration of the current symbol.
-     */
-    includeDeclaration: boolean;
-}
-/**
- * The reference provider interface defines the contract between extensions and
- * the [find references](https://code.visualstudio.com/docs/editor/editingevolved#_peek)-feature.
- */
-interface ReferenceProvider {
-    /**
-     * Provide a set of project-wide references for the given position and document.
-     */
-    provideReferences(model: ITextModel, position: Position, context: ReferenceContext, token: CancellationToken): ProviderResult<Location[]>;
-}
-/**
- * Represents a location inside a resource, such as a line
- * inside a text file.
- */
-interface Location {
-    /**
-     * The resource identifier of this location.
-     */
-    uri: URI;
-    /**
-     * The document range of this locations.
-     */
-    range: IRange;
-}
-interface LocationLink {
-    /**
-     * A range to select where this link originates from.
-     */
-    originSelectionRange?: IRange;
-    /**
-     * The target uri this link points to.
-     */
-    uri: URI;
-    /**
-     * The full range this link points to.
-     */
-    range: IRange;
-    /**
-     * A range to select this link points to. Must be contained
-     * in `LocationLink.range`.
-     */
-    targetSelectionRange?: IRange;
-}
-type Definition = Location | Location[] | LocationLink[];
-/**
- * The definition provider interface defines the contract between extensions and
- * the [go to definition](https://code.visualstudio.com/docs/editor/editingevolved#_go-to-definition)
- * and peek definition features.
- */
-interface DefinitionProvider {
-    /**
-     * Provide the definition of the symbol at the given position and document.
-     */
-    provideDefinition(model: ITextModel, position: Position, token: CancellationToken): ProviderResult<Definition | LocationLink[]>;
-}
-/**
- * The definition provider interface defines the contract between extensions and
- * the [go to definition](https://code.visualstudio.com/docs/editor/editingevolved#_go-to-definition)
- * and peek definition features.
- */
-interface DeclarationProvider {
-    /**
-     * Provide the declaration of the symbol at the given position and document.
-     */
-    provideDeclaration(model: ITextModel, position: Position, token: CancellationToken): ProviderResult<Definition | LocationLink[]>;
-}
-/**
- * The implementation provider interface defines the contract between extensions and
- * the go to implementation feature.
- */
-interface ImplementationProvider {
-    /**
-     * Provide the implementation of the symbol at the given position and document.
-     */
-    provideImplementation(model: ITextModel, position: Position, token: CancellationToken): ProviderResult<Definition | LocationLink[]>;
-}
-/**
- * The type definition provider interface defines the contract between extensions and
- * the go to type definition feature.
- */
-interface TypeDefinitionProvider {
-    /**
-     * Provide the type definition of the symbol at the given position and document.
-     */
-    provideTypeDefinition(model: ITextModel, position: Position, token: CancellationToken): ProviderResult<Definition | LocationLink[]>;
-}
-/**
- * A symbol kind.
- */
-declare const enum SymbolKind {
-    File = 0,
-    Module = 1,
-    Namespace = 2,
-    Package = 3,
-    Class = 4,
-    Method = 5,
-    Property = 6,
-    Field = 7,
-    Constructor = 8,
-    Enum = 9,
-    Interface = 10,
-    Function = 11,
-    Variable = 12,
-    Constant = 13,
-    String = 14,
-    Number = 15,
-    Boolean = 16,
-    Array = 17,
-    Object = 18,
-    Key = 19,
-    Null = 20,
-    EnumMember = 21,
-    Struct = 22,
-    Event = 23,
-    Operator = 24,
-    TypeParameter = 25
-}
-declare const enum SymbolTag {
-    Deprecated = 1
-}
-interface DocumentSymbol {
-    name: string;
-    detail: string;
-    kind: SymbolKind;
-    tags: ReadonlyArray<SymbolTag>;
-    containerName?: string;
-    range: IRange;
-    selectionRange: IRange;
-    children?: DocumentSymbol[];
-}
-/**
- * The document symbol provider interface defines the contract between extensions and
- * the [go to symbol](https://code.visualstudio.com/docs/editor/editingevolved#_go-to-symbol)-feature.
- */
-interface DocumentSymbolProvider {
-    displayName?: string;
-    /**
-     * Provide symbol information for the given document.
-     */
-    provideDocumentSymbols(model: ITextModel, token: CancellationToken): ProviderResult<DocumentSymbol[]>;
-}
-interface TextEdit {
-    range: IRange;
-    text: string;
-    eol?: EndOfLineSequence;
-}
-/**
- * Interface used to format a model
- */
-interface FormattingOptions {
-    /**
-     * Size of a tab in spaces.
-     */
-    tabSize: number;
-    /**
-     * Prefer spaces over tabs.
-     */
-    insertSpaces: boolean;
-    /**
-     * The list of multiple ranges to format at once, if the provider supports it.
-     */
-    ranges?: Range[];
-}
-/**
- * The document formatting provider interface defines the contract between extensions and
- * the formatting-feature.
- */
-interface DocumentFormattingEditProvider {
-    /**
-     * @internal
-     */
-    readonly extensionId?: ExtensionIdentifier;
-    readonly displayName?: string;
-    /**
-     * Provide formatting edits for a whole document.
-     */
-    provideDocumentFormattingEdits(model: ITextModel, options: FormattingOptions, token: CancellationToken): ProviderResult<TextEdit[]>;
-}
-/**
- * The document formatting provider interface defines the contract between extensions and
- * the formatting-feature.
- */
-interface DocumentRangeFormattingEditProvider {
-    /**
-     * @internal
-     */
-    readonly extensionId?: ExtensionIdentifier;
-    readonly displayName?: string;
-    /**
-     * Provide formatting edits for a range in a document.
-     *
-     * The given range is a hint and providers can decide to format a smaller
-     * or larger range. Often this is done by adjusting the start and end
-     * of the range to full syntax nodes.
-     */
-    provideDocumentRangeFormattingEdits(model: ITextModel, range: Range, options: FormattingOptions, token: CancellationToken): ProviderResult<TextEdit[]>;
-    provideDocumentRangesFormattingEdits?(model: ITextModel, ranges: Range[], options: FormattingOptions, token: CancellationToken): ProviderResult<TextEdit[]>;
-}
-/**
- * The document formatting provider interface defines the contract between extensions and
- * the formatting-feature.
- */
-interface OnTypeFormattingEditProvider {
-    /**
-     * @internal
-     */
-    readonly extensionId?: ExtensionIdentifier;
-    autoFormatTriggerCharacters: string[];
-    /**
-     * Provide formatting edits after a character has been typed.
-     *
-     * The given position and character should hint to the provider
-     * what range the position to expand to, like find the matching `{`
-     * when `}` has been entered.
-     */
-    provideOnTypeFormattingEdits(model: ITextModel, position: Position, ch: string, options: FormattingOptions, token: CancellationToken): ProviderResult<TextEdit[]>;
-}
-/**
- * @internal
- */
-interface IInplaceReplaceSupportResult {
-    value: string;
-    range: IRange;
-}
-/**
- * A link inside the editor.
- */
-interface ILink {
-    range: IRange;
-    url?: URI | string;
-    tooltip?: string;
-}
-interface ILinksList {
-    links: ILink[];
-    dispose?(): void;
-}
-/**
- * A provider of links.
- */
-interface LinkProvider {
-    provideLinks(model: ITextModel, token: CancellationToken): ProviderResult<ILinksList>;
-    resolveLink?: (link: ILink, token: CancellationToken) => ProviderResult<ILink>;
-}
-/**
- * A color in RGBA format.
- */
-interface IColor {
-    /**
-     * The red component in the range [0-1].
-     */
-    readonly red: number;
-    /**
-     * The green component in the range [0-1].
-     */
-    readonly green: number;
-    /**
-     * The blue component in the range [0-1].
-     */
-    readonly blue: number;
-    /**
-     * The alpha component in the range [0-1].
-     */
-    readonly alpha: number;
-}
-/**
- * String representations for a color
- */
-interface IColorPresentation {
-    /**
-     * The label of this color presentation. It will be shown on the color
-     * picker header. By default this is also the text that is inserted when selecting
-     * this color presentation.
-     */
-    label: string;
-    /**
-     * An {@link TextEdit edit} which is applied to a document when selecting
-     * this presentation for the color.
-     */
-    textEdit?: TextEdit;
-    /**
-     * An optional array of additional {@link TextEdit text edits} that are applied when
-     * selecting this color presentation.
-     */
-    additionalTextEdits?: TextEdit[];
-}
-/**
- * A color range is a range in a text model which represents a color.
- */
-interface IColorInformation {
-    /**
-     * The range within the model.
-     */
-    range: IRange;
-    /**
-     * The color represented in this range.
-     */
-    color: IColor;
-}
-/**
- * A provider of colors for editor models.
- */
-interface DocumentColorProvider {
-    /**
-     * Provides the color ranges for a specific model.
-     */
-    provideDocumentColors(model: ITextModel, token: CancellationToken): ProviderResult<IColorInformation[]>;
-    /**
-     * Provide the string representations for a color.
-     */
-    provideColorPresentations(model: ITextModel, colorInfo: IColorInformation, token: CancellationToken): ProviderResult<IColorPresentation[]>;
-}
-interface SelectionRange {
-    range: IRange;
-}
-interface SelectionRangeProvider {
-    /**
-     * Provide ranges that should be selected from the given position.
-     */
-    provideSelectionRanges(model: ITextModel, positions: Position[], token: CancellationToken): ProviderResult<SelectionRange[][]>;
-}
-interface FoldingContext {
-}
-/**
- * A provider of folding ranges for editor models.
- */
-interface FoldingRangeProvider {
-    /**
-     * @internal
-     */
-    readonly id?: string;
-    /**
-     * An optional event to signal that the folding ranges from this provider have changed.
-     */
-    onDidChange?: Event<this>;
-    /**
-     * Provides the folding ranges for a specific model.
-     */
-    provideFoldingRanges(model: ITextModel, context: FoldingContext, token: CancellationToken): ProviderResult<FoldingRange[]>;
-}
-interface FoldingRange {
-    /**
-     * The one-based start line of the range to fold. The folded area starts after the line's last character.
-     */
-    start: number;
-    /**
-     * The one-based end line of the range to fold. The folded area ends with the line's last character.
-     */
-    end: number;
-    /**
-     * Describes the {@link FoldingRangeKind Kind} of the folding range such as {@link FoldingRangeKind.Comment Comment} or
-     * {@link FoldingRangeKind.Region Region}. The kind is used to categorize folding ranges and used by commands
-     * like 'Fold all comments'. See
-     * {@link FoldingRangeKind} for an enumeration of standardized kinds.
-     */
-    kind?: FoldingRangeKind;
-}
-declare class FoldingRangeKind {
-    value: string;
-    /**
-     * Kind for folding range representing a comment. The value of the kind is 'comment'.
-     */
-    static readonly Comment: FoldingRangeKind;
-    /**
-     * Kind for folding range representing a import. The value of the kind is 'imports'.
-     */
-    static readonly Imports: FoldingRangeKind;
-    /**
-     * Kind for folding range representing regions (for example marked by `#region`, `#endregion`).
-     * The value of the kind is 'region'.
-     */
-    static readonly Region: FoldingRangeKind;
-    /**
-     * Returns a {@link FoldingRangeKind} for the given value.
-     *
-     * @param value of the kind.
-     */
-    static fromValue(value: string): FoldingRangeKind;
-    /**
-     * Creates a new {@link FoldingRangeKind}.
-     *
-     * @param value of the kind.
-     */
-    constructor(value: string);
-}
-interface WorkspaceEditMetadata {
-    needsConfirmation: boolean;
-    label: string;
-    description?: string;
-    /**
-     * @internal
-     */
-    iconPath?: ThemeIcon | URI | {
-        light: URI;
-        dark: URI;
-    };
-}
-interface WorkspaceFileEditOptions {
-    overwrite?: boolean;
-    ignoreIfNotExists?: boolean;
-    ignoreIfExists?: boolean;
-    recursive?: boolean;
-    copy?: boolean;
-    folder?: boolean;
-    skipTrashBin?: boolean;
-    maxSize?: number;
-    /**
-     * @internal
-     */
-    contents?: Promise<VSBuffer>;
-}
-interface IWorkspaceFileEdit {
-    oldResource?: URI;
-    newResource?: URI;
-    options?: WorkspaceFileEditOptions;
-    metadata?: WorkspaceEditMetadata;
-}
-interface IWorkspaceTextEdit {
-    resource: URI;
-    textEdit: TextEdit & {
-        insertAsSnippet?: boolean;
-    };
-    versionId: number | undefined;
-    metadata?: WorkspaceEditMetadata;
-}
-interface WorkspaceEdit {
-    edits: Array<IWorkspaceTextEdit | IWorkspaceFileEdit>;
-}
-interface Rejection {
-    rejectReason?: string;
-}
-interface RenameLocation {
-    range: IRange;
-    text: string;
-}
-interface RenameProvider {
-    provideRenameEdits(model: ITextModel, position: Position, newName: string, token: CancellationToken): ProviderResult<WorkspaceEdit & Rejection>;
-    resolveRenameLocation?(model: ITextModel, position: Position, token: CancellationToken): ProviderResult<RenameLocation & Rejection>;
-}
-interface Command {
-    id: string;
-    title: string;
-    tooltip?: string;
-    arguments?: any[];
-}
-/**
- * @internal
- */
-declare namespace Command {
-    /**
-     * @internal
-     */
-    function is(obj: any): obj is Command;
-}
-interface CodeLens {
-    range: IRange;
-    id?: string;
-    command?: Command;
-}
-interface CodeLensList {
-    lenses: CodeLens[];
-    dispose(): void;
-}
-interface CodeLensProvider {
-    onDidChange?: Event<this>;
-    provideCodeLenses(model: ITextModel, token: CancellationToken): ProviderResult<CodeLensList>;
-    resolveCodeLens?(model: ITextModel, codeLens: CodeLens, token: CancellationToken): ProviderResult<CodeLens>;
-}
-declare enum InlayHintKind {
-    Type = 1,
-    Parameter = 2
-}
-interface InlayHintLabelPart {
-    label: string;
-    tooltip?: string | IMarkdownString;
-    command?: Command;
-    location?: Location;
-}
-interface InlayHint {
-    label: string | InlayHintLabelPart[];
-    tooltip?: string | IMarkdownString;
-    textEdits?: TextEdit[];
-    position: IPosition;
-    kind?: InlayHintKind;
-    paddingLeft?: boolean;
-    paddingRight?: boolean;
-}
-interface InlayHintList {
-    hints: InlayHint[];
-    dispose(): void;
-}
-interface InlayHintsProvider {
-    displayName?: string;
-    onDidChangeInlayHints?: Event<void>;
-    provideInlayHints(model: ITextModel, range: Range, token: CancellationToken): ProviderResult<InlayHintList>;
-    resolveInlayHint?(hint: InlayHint, token: CancellationToken): ProviderResult<InlayHint>;
-}
-interface SemanticTokensLegend {
-    readonly tokenTypes: string[];
-    readonly tokenModifiers: string[];
-}
-interface SemanticTokens {
-    readonly resultId?: string;
-    readonly data: Uint32Array;
-}
-interface SemanticTokensEdit {
-    readonly start: number;
-    readonly deleteCount: number;
-    readonly data?: Uint32Array;
-}
-interface SemanticTokensEdits {
-    readonly resultId?: string;
-    readonly edits: SemanticTokensEdit[];
-}
-interface DocumentSemanticTokensProvider {
-    onDidChange?: Event<void>;
-    getLegend(): SemanticTokensLegend;
-    provideDocumentSemanticTokens(model: ITextModel, lastResultId: string | null, token: CancellationToken): ProviderResult<SemanticTokens | SemanticTokensEdits>;
-    releaseDocumentSemanticTokens(resultId: string | undefined): void;
-}
-interface DocumentRangeSemanticTokensProvider {
-    getLegend(): SemanticTokensLegend;
-    provideDocumentRangeSemanticTokens(model: ITextModel, range: Range, token: CancellationToken): ProviderResult<SemanticTokens>;
-}
-/**
- * @internal
- */
-interface DocumentOnDropEdit {
-    readonly id: string;
-    readonly label: string;
-    readonly priority: number;
-    insertText: string | {
-        readonly snippet: string;
-    };
-    additionalEdit?: WorkspaceEdit;
-}
-/**
- * @internal
- */
-interface DocumentOnDropEditProvider {
-    readonly dropMimeTypes?: readonly string[];
-    provideDocumentOnDropEdits(model: ITextModel, position: IPosition, dataTransfer: IReadonlyVSDataTransfer, token: CancellationToken): ProviderResult<DocumentOnDropEdit>;
-}
-
-interface IViewLineTokens {
-    equals(other: IViewLineTokens): boolean;
-    getCount(): number;
-    getForeground(tokenIndex: number): ColorId;
-    getEndOffset(tokenIndex: number): number;
-    getClassName(tokenIndex: number): string;
-    getInlineStyle(tokenIndex: number, colorMap: string[]): string;
-    getPresentation(tokenIndex: number): ITokenPresentation;
-    findTokenIndexAtOffset(offset: number): number;
-    getLineContent(): string;
-    getMetadata(tokenIndex: number): number;
-    getLanguageId(tokenIndex: number): string;
-}
-declare class LineTokens implements IViewLineTokens {
-    _lineTokensBrand: void;
-    private readonly _tokens;
-    private readonly _tokensCount;
-    private readonly _text;
-    private readonly _languageIdCodec;
-    static defaultTokenMetadata: number;
-    static createEmpty(lineContent: string, decoder: ILanguageIdCodec): LineTokens;
-    constructor(tokens: Uint32Array, text: string, decoder: ILanguageIdCodec);
-    equals(other: IViewLineTokens): boolean;
-    slicedEquals(other: LineTokens, sliceFromTokenIndex: number, sliceTokenCount: number): boolean;
-    getLineContent(): string;
-    getCount(): number;
-    getStartOffset(tokenIndex: number): number;
-    getMetadata(tokenIndex: number): number;
-    getLanguageId(tokenIndex: number): string;
-    getStandardTokenType(tokenIndex: number): StandardTokenType;
-    getForeground(tokenIndex: number): ColorId;
-    getClassName(tokenIndex: number): string;
-    getInlineStyle(tokenIndex: number, colorMap: string[]): string;
-    getPresentation(tokenIndex: number): ITokenPresentation;
-    getEndOffset(tokenIndex: number): number;
-    /**
-     * Find the token containing offset `offset`.
-     * @param offset The search offset
-     * @return The index of the token containing the offset.
-     */
-    findTokenIndexAtOffset(offset: number): number;
-    inflate(): IViewLineTokens;
-    sliceAndInflate(startOffset: number, endOffset: number, deltaOffset: number): IViewLineTokens;
-    static convertToEndOffset(tokens: Uint32Array, lineTextLength: number): void;
-    static findIndexInTokensArray(tokens: Uint32Array, desiredIndex: number): number;
-    /**
-     * @pure
-     * @param insertTokens Must be sorted by offset.
-    */
-    withInserted(insertTokens: {
-        offset: number;
-        text: string;
-        tokenMetadata: number;
-    }[]): LineTokens;
-}
-
-declare class ScopedLineTokens {
-    _scopedLineTokensBrand: void;
-    readonly languageId: string;
-    private readonly _actual;
-    private readonly _firstTokenIndex;
-    private readonly _lastTokenIndex;
-    readonly firstCharOffset: number;
-    private readonly _lastCharOffset;
-    constructor(actual: LineTokens, languageId: string, firstTokenIndex: number, lastTokenIndex: number, firstCharOffset: number, lastCharOffset: number);
-    getLineContent(): string;
-    getActualLineContentBefore(offset: number): string;
-    getTokenCount(): number;
-    findTokenIndexAtOffset(offset: number): number;
-    getStandardTokenType(tokenIndex: number): StandardTokenType;
-}
-
-/**
- * Describes how comments for a language work.
- */
-interface CommentRule {
-    /**
-     * The line comment token, like `// this is a comment`
-     */
-    lineComment?: string | null;
-    /**
-     * The block comment character pair, like `/* block comment *&#47;`
-     */
-    blockComment?: CharacterPair | null;
-}
-/**
- * The language configuration interface defines the contract between extensions and
- * various editor features, like automatic bracket insertion, automatic indentation etc.
- */
-interface LanguageConfiguration {
-    /**
-     * The language's comment settings.
-     */
-    comments?: CommentRule;
-    /**
-     * The language's brackets.
-     * This configuration implicitly affects pressing Enter around these brackets.
-     */
-    brackets?: CharacterPair[];
-    /**
-     * The language's word definition.
-     * If the language supports Unicode identifiers (e.g. JavaScript), it is preferable
-     * to provide a word definition that uses exclusion of known separators.
-     * e.g.: A regex that matches anything except known separators (and dot is allowed to occur in a floating point number):
-     *   /(-?\d*\.\d\w*)|([^\`\~\!\@\#\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g
-     */
-    wordPattern?: RegExp;
-    /**
-     * The language's indentation settings.
-     */
-    indentationRules?: IndentationRule;
-    /**
-     * The language's rules to be evaluated when pressing Enter.
-     */
-    onEnterRules?: OnEnterRule[];
-    /**
-     * The language's auto closing pairs. The 'close' character is automatically inserted with the
-     * 'open' character is typed. If not set, the configured brackets will be used.
-     */
-    autoClosingPairs?: IAutoClosingPairConditional[];
-    /**
-     * The language's surrounding pairs. When the 'open' character is typed on a selection, the
-     * selected string is surrounded by the open and close characters. If not set, the autoclosing pairs
-     * settings will be used.
-     */
-    surroundingPairs?: IAutoClosingPair[];
-    /**
-     * Defines a list of bracket pairs that are colorized depending on their nesting level.
-     * If not set, the configured brackets will be used.
-    */
-    colorizedBracketPairs?: CharacterPair[];
-    /**
-     * Defines what characters must be after the cursor for bracket or quote autoclosing to occur when using the \'languageDefined\' autoclosing setting.
-     *
-     * This is typically the set of characters which can not start an expression, such as whitespace, closing brackets, non-unary operators, etc.
-     */
-    autoCloseBefore?: string;
-    /**
-     * The language's folding rules.
-     */
-    folding?: FoldingRules;
-    /**
-     * **Deprecated** Do not use.
-     *
-     * @deprecated Will be replaced by a better API soon.
-     */
-    __electricCharacterSupport?: {
-        docComment?: IDocComment;
-    };
-}
-/**
- * Describes indentation rules for a language.
- */
-interface IndentationRule {
-    /**
-     * If a line matches this pattern, then all the lines after it should be unindented once (until another rule matches).
-     */
-    decreaseIndentPattern: RegExp;
-    /**
-     * If a line matches this pattern, then all the lines after it should be indented once (until another rule matches).
-     */
-    increaseIndentPattern: RegExp;
-    /**
-     * If a line matches this pattern, then **only the next line** after it should be indented once.
-     */
-    indentNextLinePattern?: RegExp | null;
-    /**
-     * If a line matches this pattern, then its indentation should not be changed and it should not be evaluated against the other rules.
-     */
-    unIndentedLinePattern?: RegExp | null;
-}
-/**
- * Describes language specific folding markers such as '#region' and '#endregion'.
- * The start and end regexes will be tested against the contents of all lines and must be designed efficiently:
- * - the regex should start with '^'
- * - regexp flags (i, g) are ignored
- */
-interface FoldingMarkers {
-    start: RegExp;
-    end: RegExp;
-}
-/**
- * Describes folding rules for a language.
- */
-interface FoldingRules {
-    /**
-     * Used by the indentation based strategy to decide whether empty lines belong to the previous or the next block.
-     * A language adheres to the off-side rule if blocks in that language are expressed by their indentation.
-     * See [wikipedia](https://en.wikipedia.org/wiki/Off-side_rule) for more information.
-     * If not set, `false` is used and empty lines belong to the previous block.
-     */
-    offSide?: boolean;
-    /**
-     * Region markers used by the language.
-     */
-    markers?: FoldingMarkers;
-}
-/**
- * Describes a rule to be evaluated when pressing Enter.
- */
-interface OnEnterRule {
-    /**
-     * This rule will only execute if the text before the cursor matches this regular expression.
-     */
-    beforeText: RegExp;
-    /**
-     * This rule will only execute if the text after the cursor matches this regular expression.
-     */
-    afterText?: RegExp;
-    /**
-     * This rule will only execute if the text above the this line matches this regular expression.
-     */
-    previousLineText?: RegExp;
-    /**
-     * The action to execute.
-     */
-    action: EnterAction;
-}
-/**
- * Definition of documentation comments (e.g. Javadoc/JSdoc)
- */
-interface IDocComment {
-    /**
-     * The string that starts a doc comment (e.g. '/**')
-     */
-    open: string;
-    /**
-     * The string that appears on the last line and closes the doc comment (e.g. ' * /').
-     */
-    close?: string;
-}
-/**
- * A tuple of two characters, like a pair of
- * opening and closing brackets.
- */
-type CharacterPair = [string, string];
-interface IAutoClosingPair {
-    open: string;
-    close: string;
-}
-interface IAutoClosingPairConditional extends IAutoClosingPair {
-    notIn?: string[];
-}
-/**
- * Describes what to do with the indentation when pressing Enter.
- */
-declare enum IndentAction {
-    /**
-     * Insert new line and copy the previous line's indentation.
-     */
-    None = 0,
-    /**
-     * Insert new line and indent once (relative to the previous line's indentation).
-     */
-    Indent = 1,
-    /**
-     * Insert two new lines:
-     *  - the first one indented which will hold the cursor
-     *  - the second one at the same indentation level
-     */
-    IndentOutdent = 2,
-    /**
-     * Insert new line and outdent once (relative to the previous line's indentation).
-     */
-    Outdent = 3
-}
-/**
- * Describes what to do when pressing Enter.
- */
-interface EnterAction {
-    /**
-     * Describe what to do with the indentation.
-     */
-    indentAction: IndentAction;
-    /**
-     * Describes text to be appended after the new line and after the indentation.
-     */
-    appendText?: string;
-    /**
-     * Describes the number of characters to remove from the new line's indentation.
-     */
-    removeText?: number;
-}
-/**
- * @internal
- */
-declare class StandardAutoClosingPairConditional {
-    readonly open: string;
-    readonly close: string;
-    private readonly _inString;
-    private readonly _inComment;
-    private readonly _inRegEx;
-    private _neutralCharacter;
-    private _neutralCharacterSearched;
-    constructor(source: IAutoClosingPairConditional);
-    isOK(standardToken: StandardTokenType): boolean;
-    shouldAutoClose(context: ScopedLineTokens, column: number): boolean;
-    private _findNeutralCharacterInRange;
-    /**
-     * Find a character in the range [0-9a-zA-Z] that does not appear in the open or close
-     */
-    findNeutralCharacter(): string | null;
-}
-/**
- * @internal
- */
-declare class AutoClosingPairs {
-    /** Key is first character of open */
-    readonly autoClosingPairsOpenByStart: Map<string, StandardAutoClosingPairConditional[]>;
-    /** Key is last character of open */
-    readonly autoClosingPairsOpenByEnd: Map<string, StandardAutoClosingPairConditional[]>;
-    /** Key is first character of close */
-    readonly autoClosingPairsCloseByStart: Map<string, StandardAutoClosingPairConditional[]>;
-    /** Key is last character of close */
-    readonly autoClosingPairsCloseByEnd: Map<string, StandardAutoClosingPairConditional[]>;
-    /** Key is close. Only has pairs that are a single character */
-    readonly autoClosingPairsCloseSingleChar: Map<string, StandardAutoClosingPairConditional[]>;
-    constructor(autoClosingPairs: StandardAutoClosingPairConditional[]);
-}
-
-/**
- * Captures all bracket related configurations for a single language.
- * Immutable.
-*/
-declare class LanguageBracketsConfiguration {
-    readonly languageId: string;
-    private readonly _openingBrackets;
-    private readonly _closingBrackets;
-    constructor(languageId: string, config: LanguageConfiguration);
-    /**
-     * No two brackets have the same bracket text.
-    */
-    get openingBrackets(): readonly OpeningBracketKind[];
-    /**
-     * No two brackets have the same bracket text.
-    */
-    get closingBrackets(): readonly ClosingBracketKind[];
-    getOpeningBracketInfo(bracketText: string): OpeningBracketKind | undefined;
-    getClosingBracketInfo(bracketText: string): ClosingBracketKind | undefined;
-    getBracketInfo(bracketText: string): BracketKind | undefined;
-}
-type BracketKind = OpeningBracketKind | ClosingBracketKind;
-declare class BracketKindBase {
-    protected readonly config: LanguageBracketsConfiguration;
-    readonly bracketText: string;
-    constructor(config: LanguageBracketsConfiguration, bracketText: string);
-    get languageId(): string;
-}
-declare class OpeningBracketKind extends BracketKindBase {
-    readonly openedBrackets: ReadonlySet<ClosingBracketKind>;
-    readonly isOpeningBracket = true;
-    constructor(config: LanguageBracketsConfiguration, bracketText: string, openedBrackets: ReadonlySet<ClosingBracketKind>);
-}
-declare class ClosingBracketKind extends BracketKindBase {
-    /**
-     * Non empty array of all opening brackets this bracket closes.
-    */
-    readonly openingBrackets: ReadonlySet<OpeningBracketKind>;
-    private readonly openingColorizedBrackets;
-    readonly isOpeningBracket = false;
-    constructor(config: LanguageBracketsConfiguration, bracketText: string, 
-    /**
-     * Non empty array of all opening brackets this bracket closes.
-    */
-    openingBrackets: ReadonlySet<OpeningBracketKind>, openingColorizedBrackets: ReadonlySet<OpeningBracketKind>);
-    /**
-     * Checks if this bracket closes the given other bracket.
-     * If the bracket infos come from different configurations, this method will return false.
-    */
-    closes(other: OpeningBracketKind): boolean;
-    closesColorized(other: OpeningBracketKind): boolean;
-    getOpeningBrackets(): readonly OpeningBracketKind[];
-}
-
-declare class CharacterPairSupport {
-    static readonly DEFAULT_AUTOCLOSE_BEFORE_LANGUAGE_DEFINED_QUOTES = ";:.,=}])> \n\t";
-    static readonly DEFAULT_AUTOCLOSE_BEFORE_LANGUAGE_DEFINED_BRACKETS = "'\"`;:.,=}])> \n\t";
-    static readonly DEFAULT_AUTOCLOSE_BEFORE_WHITESPACE = " \n\t";
-    private readonly _autoClosingPairs;
-    private readonly _surroundingPairs;
-    private readonly _autoCloseBeforeForQuotes;
-    private readonly _autoCloseBeforeForBrackets;
-    constructor(config: LanguageConfiguration);
-    getAutoClosingPairs(): StandardAutoClosingPairConditional[];
-    getAutoCloseBeforeSet(forQuotes: boolean): string;
-    getSurroundingPairs(): IAutoClosingPair[];
-}
-
-/**
- * Represents a grouping of colliding bracket pairs.
- *
- * Most of the times this contains a single bracket pair,
- * but sometimes this contains multiple bracket pairs in cases
- * where the same string appears as a closing bracket for multiple
- * bracket pairs, or the same string appears an opening bracket for
- * multiple bracket pairs.
- *
- * e.g. of a group containing a single pair:
- *   open: ['{'], close: ['}']
- *
- * e.g. of a group containing multiple pairs:
- *   open: ['if', 'for'], close: ['end', 'end']
- */
-declare class RichEditBracket {
-    _richEditBracketBrand: void;
-    readonly languageId: string;
-    /**
-     * A 0-based consecutive unique identifier for this bracket pair.
-     * If a language has 5 bracket pairs, out of which 2 are grouped together,
-     * it is expected that the `index` goes from 0 to 4.
-     */
-    readonly index: number;
-    /**
-     * The open sequence for each bracket pair contained in this group.
-     *
-     * The open sequence at a specific index corresponds to the
-     * closing sequence at the same index.
-     *
-     * [ open[i], closed[i] ] represent a bracket pair.
-     */
-    readonly open: string[];
-    /**
-     * The close sequence for each bracket pair contained in this group.
-     *
-     * The close sequence at a specific index corresponds to the
-     * opening sequence at the same index.
-     *
-     * [ open[i], closed[i] ] represent a bracket pair.
-     */
-    readonly close: string[];
-    /**
-     * A regular expression that is useful to search for this bracket pair group in a string.
-     *
-     * This regular expression is built in a way that it is aware of the other bracket
-     * pairs defined for the language, so it might match brackets from other groups.
-     *
-     * See the fine details in `getRegexForBracketPair`.
-     */
-    readonly forwardRegex: RegExp;
-    /**
-     * A regular expression that is useful to search for this bracket pair group in a string backwards.
-     *
-     * This regular expression is built in a way that it is aware of the other bracket
-     * pairs defined for the language, so it might match brackets from other groups.
-     *
-     * See the fine defails in `getReversedRegexForBracketPair`.
-     */
-    readonly reversedRegex: RegExp;
-    private readonly _openSet;
-    private readonly _closeSet;
-    constructor(languageId: string, index: number, open: string[], close: string[], forwardRegex: RegExp, reversedRegex: RegExp);
-    /**
-     * Check if the provided `text` is an open bracket in this group.
-     */
-    isOpen(text: string): boolean;
-    /**
-     * Check if the provided `text` is a close bracket in this group.
-     */
-    isClose(text: string): boolean;
-    private static _toSet;
-}
-declare class RichEditBrackets {
-    _richEditBracketsBrand: void;
-    /**
-     * All groups of brackets defined for this language.
-     */
-    readonly brackets: RichEditBracket[];
-    /**
-     * A regular expression that is useful to search for all bracket pairs in a string.
-     *
-     * See the fine details in `getRegexForBrackets`.
-     */
-    readonly forwardRegex: RegExp;
-    /**
-     * A regular expression that is useful to search for all bracket pairs in a string backwards.
-     *
-     * See the fine details in `getReversedRegexForBrackets`.
-     */
-    readonly reversedRegex: RegExp;
-    /**
-     * The length (i.e. str.length) for the longest bracket pair.
-     */
-    readonly maxBracketLength: number;
-    /**
-     * A map useful for decoding a regex match and finding which bracket group was matched.
-     */
-    readonly textIsBracket: {
-        [text: string]: RichEditBracket;
-    };
-    /**
-     * A set useful for decoding if a regex match is the open bracket of a bracket pair.
-     */
-    readonly textIsOpenBracket: {
-        [text: string]: boolean;
-    };
-    constructor(languageId: string, _brackets: readonly CharacterPair[]);
-}
-
-/**
- * Interface used to support electric characters
- * @internal
- */
-interface IElectricAction {
-    matchOpenBracket: string;
-}
-declare class BracketElectricCharacterSupport {
-    private readonly _richEditBrackets;
-    constructor(richEditBrackets: RichEditBrackets | null);
-    getElectricCharacters(): string[];
-    onElectricCharacter(character: string, context: ScopedLineTokens, column: number): IElectricAction | null;
-}
-
-declare class IndentRulesSupport {
-    private readonly _indentationRules;
-    constructor(indentationRules: IndentationRule);
-    shouldIncrease(text: string): boolean;
-    shouldDecrease(text: string): boolean;
-    shouldIndentNextLine(text: string): boolean;
-    shouldIgnore(text: string): boolean;
-    getIndentMetadata(text: string): number;
-}
-
-/**
- * Interface used to support insertion of mode specific comments.
- */
-interface ICommentsConfiguration {
-    lineCommentToken?: string;
-    blockCommentStartToken?: string;
-    blockCommentEndToken?: string;
-}
-declare class LanguageConfigurationServiceChangeEvent {
-    readonly languageId: string | undefined;
-    constructor(languageId: string | undefined);
-    affects(languageId: string): boolean;
-}
-interface ILanguageConfigurationService {
-    readonly _serviceBrand: undefined;
-    onDidChange: Event<LanguageConfigurationServiceChangeEvent>;
-    /**
-     * @param priority Use a higher number for higher priority
-     */
-    register(languageId: string, configuration: LanguageConfiguration, priority?: number): IDisposable;
-    getLanguageConfiguration(languageId: string): ResolvedLanguageConfiguration;
-}
-declare const ILanguageConfigurationService: ServiceIdentifier<ILanguageConfigurationService>;
-/**
- * Immutable.
-*/
-declare class ResolvedLanguageConfiguration {
-    readonly languageId: string;
-    readonly underlyingConfig: LanguageConfiguration;
-    private _brackets;
-    private _electricCharacter;
-    private readonly _onEnterSupport;
-    readonly comments: ICommentsConfiguration | null;
-    readonly characterPair: CharacterPairSupport;
-    readonly wordDefinition: RegExp;
-    readonly indentRulesSupport: IndentRulesSupport | null;
-    readonly indentationRules: IndentationRule | undefined;
-    readonly foldingRules: FoldingRules;
-    readonly bracketsNew: LanguageBracketsConfiguration;
-    constructor(languageId: string, underlyingConfig: LanguageConfiguration);
-    getWordDefinition(): RegExp;
-    get brackets(): RichEditBrackets | null;
-    get electricCharacter(): BracketElectricCharacterSupport | null;
-    onEnter(autoIndent: EditorAutoIndentStrategy, previousLineText: string, beforeEnterText: string, afterEnterText: string): EnterAction | null;
-    getAutoClosingPairs(): AutoClosingPairs;
-    getAutoCloseBeforeSet(forQuotes: boolean): string;
-    getSurroundingPairs(): IAutoClosingPair[];
-    private static _handleComments;
-}
-
-interface IAction {
-    readonly id: string;
-    label: string;
-    tooltip: string;
-    class: string | undefined;
-    enabled: boolean;
-    checked?: boolean;
-    run(...args: unknown[]): unknown;
-}
-interface IActionRunner extends IDisposable {
-    readonly onDidRun: Event<IRunEvent>;
-    readonly onWillRun: Event<IRunEvent>;
-    run(action: IAction, context?: unknown): unknown;
-}
-interface IRunEvent {
-    readonly action: IAction;
-    readonly error?: Error;
-}
-declare class SubmenuAction implements IAction {
-    readonly id: string;
-    readonly label: string;
-    readonly class: string | undefined;
-    readonly tooltip: string;
-    readonly enabled: boolean;
-    readonly checked: undefined;
-    private readonly _actions;
-    get actions(): readonly IAction[];
-    constructor(id: string, label: string, actions: readonly IAction[], cssClass?: string);
-    run(): Promise<void>;
-}
-
-type Severity = Severity$1;
-type NotificationMessage = string | Error;
-declare enum NotificationPriority {
-    /**
-     * Default priority: notification will be visible unless do not disturb mode is enabled.
-     */
-    DEFAULT = 0,
-    /**
-     * Silent priority: notification will only be visible from the notifications center.
-     */
-    SILENT = 1,
-    /**
-     * Urgent priority: notification will be visible even when do not disturb mode is enabled.
-     */
-    URGENT = 2
-}
-interface INotificationProperties {
-    /**
-     * Sticky notifications are not automatically removed after a certain timeout.
-     *
-     * Currently, only 2 kinds of notifications are sticky:
-     * - Error notifications with primary actions
-     * - Notifications that show progress
-     */
-    readonly sticky?: boolean;
-    /**
-     * Allows to override the priority of the notification based on needs.
-     */
-    readonly priority?: NotificationPriority;
-    /**
-     * Adds an action to never show the notification again. The choice will be persisted
-     * such as future requests will not cause the notification to show again.
-     */
-    readonly neverShowAgain?: INeverShowAgainOptions;
-}
-declare enum NeverShowAgainScope {
-    /**
-     * Will never show this notification on the current workspace again.
-     */
-    WORKSPACE = 0,
-    /**
-     * Will never show this notification on any workspace of the same
-     * profile again.
-     */
-    PROFILE = 1,
-    /**
-     * Will never show this notification on any workspace across all
-     * profiles again.
-     */
-    APPLICATION = 2
-}
-interface INeverShowAgainOptions {
-    /**
-     * The id is used to persist the selection of not showing the notification again.
-     */
-    readonly id: string;
-    /**
-     * By default the action will show up as primary action. Setting this to true will
-     * make it a secondary action instead.
-     */
-    readonly isSecondary?: boolean;
-    /**
-     * Whether to persist the choice in the current workspace or for all workspaces. By
-     * default it will be persisted for all workspaces across all profiles
-     * (= `NeverShowAgainScope.APPLICATION`).
-     */
-    readonly scope?: NeverShowAgainScope;
-}
-interface INotification extends INotificationProperties {
-    /**
-     * The id of the notification. If provided, will be used to compare
-     * notifications with others to decide whether a notification is
-     * duplicate or not.
-     */
-    readonly id?: string;
-    /**
-     * The severity of the notification. Either `Info`, `Warning` or `Error`.
-     */
-    readonly severity: Severity;
-    /**
-     * The message of the notification. This can either be a `string` or `Error`. Messages
-     * can optionally include links in the format: `[text](link)`
-     */
-    readonly message: NotificationMessage;
-    /**
-     * The source of the notification appears as additional information.
-     */
-    readonly source?: string | {
-        label: string;
-        id: string;
-    };
-    /**
-     * Actions to show as part of the notification. Primary actions show up as
-     * buttons as part of the message and will close the notification once clicked.
-     *
-     * Secondary actions are meant to provide additional configuration or context
-     * for the notification and will show up less prominent. A notification does not
-     * close automatically when invoking a secondary action.
-     *
-     * **Note:** If your intent is to show a message with actions to the user, consider
-     * the `INotificationService.prompt()` method instead which are optimized for
-     * this usecase and much easier to use!
-     */
-    actions?: INotificationActions;
-    /**
-     * The initial set of progress properties for the notification. To update progress
-     * later on, access the `INotificationHandle.progress` property.
-     */
-    readonly progress?: INotificationProgressProperties;
-}
-interface INotificationActions {
-    /**
-     * Primary actions show up as buttons as part of the message and will close
-     * the notification once clicked.
-     *
-     * Pass `ActionWithMenuAction` for an action that has additional menu actions.
-     */
-    readonly primary?: readonly IAction[];
-    /**
-     * Secondary actions are meant to provide additional configuration or context
-     * for the notification and will show up less prominent. A notification does not
-     * close automatically when invoking a secondary action.
-     */
-    readonly secondary?: readonly IAction[];
-}
-interface INotificationProgressProperties {
-    /**
-     * Causes the progress bar to spin infinitley.
-     */
-    readonly infinite?: boolean;
-    /**
-     * Indicate the total amount of work.
-     */
-    readonly total?: number;
-    /**
-     * Indicate that a specific chunk of work is done.
-     */
-    readonly worked?: number;
-}
-interface INotificationProgress {
-    /**
-     * Causes the progress bar to spin infinitley.
-     */
-    infinite(): void;
-    /**
-     * Indicate the total amount of work.
-     */
-    total(value: number): void;
-    /**
-     * Indicate that a specific chunk of work is done.
-     */
-    worked(value: number): void;
-    /**
-     * Indicate that the long running operation is done.
-     */
-    done(): void;
-}
-interface INotificationHandle {
-    /**
-     * Will be fired once the notification is closed.
-     */
-    readonly onDidClose: Event<void>;
-    /**
-     * Will be fired whenever the visibility of the notification changes.
-     * A notification can either be visible as toast or inside the notification
-     * center if it is visible.
-     */
-    readonly onDidChangeVisibility: Event<boolean>;
-    /**
-     * Allows to indicate progress on the notification even after the
-     * notification is already visible.
-     */
-    readonly progress: INotificationProgress;
-    /**
-     * Allows to update the severity of the notification.
-     */
-    updateSeverity(severity: Severity): void;
-    /**
-     * Allows to update the message of the notification even after the
-     * notification is already visible.
-     */
-    updateMessage(message: NotificationMessage): void;
-    /**
-     * Allows to update the actions of the notification even after the
-     * notification is already visible.
-     */
-    updateActions(actions?: INotificationActions): void;
-    /**
-     * Hide the notification and remove it from the notification center.
-     */
-    close(): void;
-}
-interface IBasePromptChoice {
-    /**
-     * Label to show for the choice to the user.
-     */
-    readonly label: string;
-    /**
-     * Whether to keep the notification open after the choice was selected
-     * by the user. By default, will close the notification upon click.
-     */
-    readonly keepOpen?: boolean;
-    /**
-     * Triggered when the user selects the choice.
-     */
-    run: () => void;
-}
-interface IPromptChoice extends IBasePromptChoice {
-    /**
-     * Primary choices show up as buttons in the notification below the message.
-     * Secondary choices show up under the gear icon in the header of the notification.
-     */
-    readonly isSecondary?: boolean;
-}
-interface IPromptChoiceWithMenu extends IPromptChoice {
-    /**
-     * Additional choices those will be shown in the dropdown menu for this choice.
-     */
-    readonly menu: IBasePromptChoice[];
-    /**
-     * Menu is not supported on secondary choices
-     */
-    readonly isSecondary: false | undefined;
-}
-interface IPromptOptions extends INotificationProperties {
-    /**
-     * Will be called if the user closed the notification without picking
-     * any of the provided choices.
-     */
-    onCancel?: () => void;
-}
-interface IStatusMessageOptions {
-    /**
-     * An optional timeout after which the status message should show. By default
-     * the status message will show immediately.
-     */
-    readonly showAfter?: number;
-    /**
-     * An optional timeout after which the status message is to be hidden. By default
-     * the status message will not hide until another status message is displayed.
-     */
-    readonly hideAfter?: number;
-}
-declare enum NotificationsFilter {
-    /**
-     * No filter is enabled.
-     */
-    OFF = 0,
-    /**
-     * All notifications are configured as silent. See
-     * `INotificationProperties.silent` for more info.
-     */
-    SILENT = 1,
-    /**
-     * All notifications are silent except error notifications.
-    */
-    ERROR = 2
-}
-declare const INotificationService: ServiceIdentifier<INotificationService>;
-/**
- * A service to bring up notifications and non-modal prompts.
- *
- * Note: use the `IDialogService` for a modal way to ask the user for input.
- */
-interface INotificationService {
-    readonly _serviceBrand: undefined;
-    /**
-     * The DND mode can be enabled or disabled
-     * and will result in all info and warning
-     * notifications to be silent.
-     */
-    doNotDisturbMode: boolean;
-    /**
-     * Emitted when a new notification is added.
-     */
-    readonly onDidAddNotification: Event<INotification>;
-    /**
-     * Emitted when a notification is removed.
-     */
-    readonly onDidRemoveNotification: Event<INotification>;
-    /**
-     * Emitted when a do not disturb mode has changed.
-     */
-    readonly onDidChangeDoNotDisturbMode: Event<void>;
-    /**
-     * Show the provided notification to the user. The returned `INotificationHandle`
-     * can be used to control the notification afterwards.
-     *
-     * **Note:** If your intent is to show a message with actions to the user, consider
-     * the `INotificationService.prompt()` method instead which are optimized for
-     * this usecase and much easier to use!
-     *
-     * @returns a handle on the notification to e.g. hide it or update message, buttons, etc.
-     */
-    notify(notification: INotification): INotificationHandle;
-    /**
-     * A convenient way of reporting infos. Use the `INotificationService.notify`
-     * method if you need more control over the notification.
-     */
-    info(message: NotificationMessage | NotificationMessage[]): void;
-    /**
-     * A convenient way of reporting warnings. Use the `INotificationService.notify`
-     * method if you need more control over the notification.
-     */
-    warn(message: NotificationMessage | NotificationMessage[]): void;
-    /**
-     * A convenient way of reporting errors. Use the `INotificationService.notify`
-     * method if you need more control over the notification.
-     */
-    error(message: NotificationMessage | NotificationMessage[]): void;
-    /**
-     * Shows a prompt in the notification area with the provided choices. The prompt
-     * is non-modal. If you want to show a modal dialog instead, use `IDialogService`.
-     *
-     * @param severity the severity of the notification. Either `Info`, `Warning` or `Error`.
-     * @param message the message to show as status.
-     * @param choices options to be chosen from.
-     * @param options provides some optional configuration options.
-     *
-     * @returns a handle on the notification to e.g. hide it or update message, buttons, etc.
-     */
-    prompt(severity: Severity, message: string, choices: (IPromptChoice | IPromptChoiceWithMenu)[], options?: IPromptOptions): INotificationHandle;
-    /**
-     * Shows a status message in the status area with the provided text.
-     *
-     * @param message the message to show as status
-     * @param options provides some optional configuration options
-     *
-     * @returns a disposable to hide the status message
-     */
-    status(message: NotificationMessage, options?: IStatusMessageOptions): IDisposable;
-}
-declare class NoOpNotification implements INotificationHandle {
-    readonly progress: NoOpProgress;
-    readonly onDidClose: Event<any>;
-    readonly onDidChangeVisibility: Event<any>;
-    updateSeverity(severity: Severity): void;
-    updateMessage(message: NotificationMessage): void;
-    updateActions(actions?: INotificationActions): void;
-    close(): void;
-}
-declare class NoOpProgress implements INotificationProgress {
-    infinite(): void;
-    done(): void;
-    total(value: number): void;
-    worked(value: number): void;
-}
-
-declare const enum WorkingCopyCapabilities {
-    /**
-     * Signals no specific capability for the working copy.
-     */
-    None = 0,
-    /**
-     * Signals that the working copy requires
-     * additional input when saving, e.g. an
-     * associated path to save to.
-     */
-    Untitled = 2,
-    /**
-     * The working copy will not indicate that
-     * it is dirty and unsaved content will be
-     * discarded without prompting if closed.
-     */
-    Scratchpad = 4
-}
-/**
- * Data to be associated with working copy backups. Use
- * `IWorkingCopyBackupService.resolve(workingCopy)` to
- * retrieve the backup when loading the working copy.
- */
-interface IWorkingCopyBackup {
-    /**
-     * Any serializable metadata to be associated with the backup.
-     */
-    meta?: IWorkingCopyBackupMeta;
-    /**
-     * The actual snapshot of the contents of the working copy at
-     * the time the backup was made.
-     */
-    content?: VSBufferReadable | VSBufferReadableStream;
-}
-/**
- * Working copy backup metadata that can be associated
- * with the backup.
- *
- * Some properties may be reserved as outlined here and
- * cannot be used.
- */
-interface IWorkingCopyBackupMeta {
-    /**
-     * Any property needs to be serializable through JSON.
-     */
-    [key: string]: unknown;
-    /**
-     * `typeId` is a reserved property that cannot be used
-     * as backup metadata.
-     */
-    typeId?: never;
-}
-/**
- * Every working copy has in common that it is identified by
- * a resource `URI` and a `typeId`. There can only be one
- * working copy registered with the same `URI` and `typeId`.
- */
-interface IWorkingCopyIdentifier {
-    /**
-     * The type identifier of the working copy for grouping
-     * working copies of the same domain together.
-     *
-     * There can only be one working copy for a given resource
-     * and type identifier.
-     */
-    readonly typeId: string;
-    /**
-     * The resource of the working copy must be unique for
-     * working copies of the same `typeId`.
-     */
-    readonly resource: URI;
-}
-interface IWorkingCopySaveEvent {
-    /**
-     * The reason why the working copy was saved.
-     */
-    readonly reason?: SaveReason;
-    /**
-     * The source of the working copy save request.
-     */
-    readonly source?: SaveSource;
-}
-/**
- * A working copy is an abstract concept to unify handling of
- * data that can be worked on (e.g. edited) in an editor.
- *
- *
- * A working copy resource may be the backing store of the data
- * (e.g. a file on disk), but that is not a requirement. If
- * your working copy is file based, consider to use the
- * `IFileWorkingCopy` instead that simplifies a lot of things
- * when working with file based working copies.
- */
-interface IWorkingCopy extends IWorkingCopyIdentifier {
-    /**
-     * Human readable name of the working copy.
-     */
-    readonly name: string;
-    /**
-     * The capabilities of the working copy.
-     */
-    readonly capabilities: WorkingCopyCapabilities;
-    /**
-     * Used by the workbench to signal if the working copy
-     * is dirty or not. Typically a working copy is dirty
-     * once changed until saved or reverted.
-     */
-    readonly onDidChangeDirty: Event<void>;
-    /**
-     * Used by the workbench e.g. to trigger auto-save
-     * (unless this working copy is untitled) and backups.
-     */
-    readonly onDidChangeContent: Event<void>;
-    /**
-     * Used by the workbench e.g. to track local history
-     * (unless this working copy is untitled).
-     */
-    readonly onDidSave: Event<IWorkingCopySaveEvent>;
-    /**
-     * Indicates that the file has unsaved changes
-     * and should confirm before closing.
-     */
-    isDirty(): boolean;
-    /**
-     * Indicates that the file has unsaved changes.
-     * Used for backup tracking and accounts for
-     * working copies that are never dirty e.g.
-     * scratchpads.
-     */
-    isModified(): boolean;
-    /**
-     * The workbench may call this method often after it receives
-     * the `onDidChangeContent` event for the working copy. The motivation
-     * is to allow to quit VSCode with dirty working copies present.
-     *
-     * Providers of working copies should use `IWorkingCopyBackupService.resolve(workingCopy)`
-     * to retrieve the backup metadata associated when loading the working copy.
-     *
-     * @param token support for cancellation
-     */
-    backup(token: CancellationToken): Promise<IWorkingCopyBackup>;
-    /**
-     * Asks the working copy to save. If the working copy was dirty, it is
-     * expected to be non-dirty after this operation has finished.
-     *
-     * @returns `true` if the operation was successful and `false` otherwise.
-     */
-    save(options?: ISaveOptions): Promise<boolean>;
-    /**
-     * Asks the working copy to revert. If the working copy was dirty, it is
-     * expected to be non-dirty after this operation has finished.
-     */
-    revert(options?: IRevertOptions): Promise<void>;
-}
-
-interface IUntitledTextEditorModel extends ITextEditorModel, ILanguageSupport, IEncodingSupport, IWorkingCopy {
-    /**
-     * Emits an event when the encoding of this untitled model changes.
-     */
-    readonly onDidChangeEncoding: Event<void>;
-    /**
-     * Emits an event when the name of this untitled model changes.
-     */
-    readonly onDidChangeName: Event<void>;
-    /**
-     * Emits an event when this untitled model is reverted.
-     */
-    readonly onDidRevert: Event<void>;
-    /**
-     * Whether this untitled text model has an associated file path.
-     */
-    readonly hasAssociatedFilePath: boolean;
-    /**
-     * Whether this model has an explicit language or not.
-     */
-    readonly hasLanguageSetExplicitly: boolean;
-    /**
-     * Sets the encoding to use for this untitled model.
-     */
-    setEncoding(encoding: string): Promise<void>;
-    /**
-     * Resolves the untitled model.
-     */
-    resolve(): Promise<void>;
-}
-
-interface INewUntitledTextEditorOptions {
-    /**
-     * Initial value of the untitled editor. An untitled editor with initial
-     * value is dirty right from the beginning.
-     */
-    initialValue?: string;
-    /**
-     * Preferred language id to use when saving the untitled editor.
-     */
-    languageId?: string;
-    /**
-     * Preferred encoding to use when saving the untitled editor.
-     */
-    encoding?: string;
-}
-interface IExistingUntitledTextEditorOptions extends INewUntitledTextEditorOptions {
-    /**
-     * A resource to identify the untitled editor to create or return
-     * if already existing.
-     *
-     * Note: the resource will not be used unless the scheme is `untitled`.
-     */
-    untitledResource?: URI;
-}
-interface INewUntitledTextEditorWithAssociatedResourceOptions extends INewUntitledTextEditorOptions {
-    /**
-     * Resource components to associate with the untitled editor. When saving
-     * the untitled editor, the associated components will be used and the user
-     * is not being asked to provide a file path.
-     *
-     * Note: currently it is not possible to specify the `scheme` to use. The
-     * untitled editor will saved to the default local or remote resource.
-     */
-    associatedResource?: {
-        authority: string;
-        path: string;
-        query: string;
-        fragment: string;
-    };
-}
-interface IUntitledTextEditorModelManager {
-    /**
-     * Events for when untitled text editors change (e.g. getting dirty, saved or reverted).
-     */
-    readonly onDidChangeDirty: Event<IUntitledTextEditorModel>;
-    /**
-     * Events for when untitled text editor encodings change.
-     */
-    readonly onDidChangeEncoding: Event<IUntitledTextEditorModel>;
-    /**
-     * Events for when untitled text editor labels change.
-     */
-    readonly onDidChangeLabel: Event<IUntitledTextEditorModel>;
-    /**
-     * Events for when untitled text editors are about to be disposed.
-     */
-    readonly onWillDispose: Event<IUntitledTextEditorModel>;
-    /**
-     * Creates a new untitled editor model with the provided options. If the `untitledResource`
-     * property is provided and the untitled editor exists, it will return that existing
-     * instance instead of creating a new one.
-     */
-    create(options?: INewUntitledTextEditorOptions): IUntitledTextEditorModel;
-    create(options?: INewUntitledTextEditorWithAssociatedResourceOptions): IUntitledTextEditorModel;
-    create(options?: IExistingUntitledTextEditorOptions): IUntitledTextEditorModel;
-    /**
-     * Returns an existing untitled editor model if already created before.
-     */
-    get(resource: URI): IUntitledTextEditorModel | undefined;
-    /**
-     * Returns the value of the untitled editor, undefined if none exists
-     * @param resource The URI of the untitled file
-     * @returns The content, or undefined
-     */
-    getValue(resource: URI): string | undefined;
-    /**
-     * Resolves an untitled editor model from the provided options. If the `untitledResource`
-     * property is provided and the untitled editor exists, it will return that existing
-     * instance instead of creating a new one.
-     */
-    resolve(options?: INewUntitledTextEditorOptions): Promise<IUntitledTextEditorModel>;
-    resolve(options?: INewUntitledTextEditorWithAssociatedResourceOptions): Promise<IUntitledTextEditorModel>;
-    resolve(options?: IExistingUntitledTextEditorOptions): Promise<IUntitledTextEditorModel>;
-    /**
-     * Figures out if the given resource has an associated resource or not.
-     */
-    isUntitledWithAssociatedResource(resource: URI): boolean;
-}
-
-/**
- * A resource based `IWorkingCopy` is backed by a `URI` from a
- * known file system provider.
- */
-interface IResourceWorkingCopy extends IWorkingCopy, IDisposable {
-    /**
-     * An event for when the orphaned state of the resource working copy changes.
-     */
-    readonly onDidChangeOrphaned: Event<void>;
-    /**
-     * Whether the resource working copy is orphaned or not.
-     */
-    isOrphaned(): boolean;
-    /**
-     * An event for when the file working copy has been disposed.
-     */
-    readonly onWillDispose: Event<void>;
-    /**
-     * Whether the file working copy has been disposed or not.
-     */
-    isDisposed(): boolean;
-}
-
-/**
- * A generic file working copy model to be reused by untitled
- * and stored file working copies.
- */
-interface IFileWorkingCopyModel extends IDisposable {
-    /**
-     * This event signals ANY changes to the contents, for example:
-     * - through the user typing into the editor
-     * - from API usage (e.g. bulk edits)
-     * - when `IFileWorkingCopyModel#update` is invoked with contents
-     *   that are different from the current contents
-     *
-     * The file working copy will listen to these changes and may mark
-     * the working copy as dirty whenever this event fires.
-     *
-     * Note: ONLY report changes to the model but not the underlying
-     * file. The file working copy is tracking changes to the file
-     * automatically.
-     */
-    readonly onDidChangeContent: Event<unknown>;
-    /**
-     * An event emitted right before disposing the model.
-     */
-    readonly onWillDispose: Event<void>;
-    /**
-     * Snapshots the model's current content for writing. This must include
-     * any changes that were made to the model that are in memory.
-     *
-     * @param token support for cancellation
-     */
-    snapshot(token: CancellationToken): Promise<VSBufferReadableStream>;
-    /**
-     * Updates the model with the provided contents. The implementation should
-     * behave in a similar fashion as `IFileWorkingCopyModelFactory#createModel`
-     * except that here the model already exists and just needs to update to
-     * the provided contents.
-     *
-     * Note: it is expected that the model fires a `onDidChangeContent` event
-     * as part of the update.
-     *
-     * @param contents the contents to use for the model
-     * @param token support for cancellation
-     */
-    update(contents: VSBufferReadableStream, token: CancellationToken): Promise<void>;
-}
-interface IFileWorkingCopy<M extends IFileWorkingCopyModel> extends IWorkingCopy, IDisposable {
-    /**
-     * An event for when the file working copy has been reverted.
-     */
-    readonly onDidRevert: Event<void>;
-    /**
-     * An event for when the file working copy has been disposed.
-     */
-    readonly onWillDispose: Event<void>;
-    /**
-     * Provides access to the underlying model of this file
-     * based working copy. As long as the file working copy
-     * has not been resolved, the model is `undefined`.
-     */
-    readonly model: M | undefined;
-    /**
-     * Resolves the file working copy and thus makes the `model`
-     * available.
-     */
-    resolve(): Promise<void>;
-    /**
-     * Whether we have a resolved model or not.
-     */
-    isResolved(): this is IResolvedFileWorkingCopy<M>;
-}
-interface IResolvedFileWorkingCopy<M extends IFileWorkingCopyModel> extends IFileWorkingCopy<M> {
-    /**
-     * A resolved file working copy has a resolved model.
-     */
-    readonly model: M;
-}
-
-/**
- * The underlying model of a stored file working copy provides some
- * methods for the stored file working copy to function. The model is
- * typically only available after the working copy has been
- * resolved via it's `resolve()` method.
- */
-interface IStoredFileWorkingCopyModel extends IFileWorkingCopyModel {
-    readonly onDidChangeContent: Event<IStoredFileWorkingCopyModelContentChangedEvent>;
-    /**
-     * A version ID of the model. If a `onDidChangeContent` is fired
-     * from the model and the last known saved `versionId` matches
-     * with the `model.versionId`, the stored file working copy will
-     * discard any dirty state.
-     *
-     * A use case is the following:
-     * - a stored file working copy gets edited and thus dirty
-     * - the user triggers undo to revert the changes
-     * - at this point the `versionId` should match the one we had saved
-     *
-     * This requires the model to be aware of undo/redo operations.
-     */
-    readonly versionId: unknown;
-    /**
-     * Close the current undo-redo element. This offers a way
-     * to create an undo/redo stop point.
-     *
-     * This method may for example be called right before the
-     * save is triggered so that the user can always undo back
-     * to the state before saving.
-     */
-    pushStackElement(): void;
-}
-interface IStoredFileWorkingCopyModelContentChangedEvent {
-    /**
-     * Flag that indicates that this event was generated while undoing.
-     */
-    readonly isUndoing: boolean;
-    /**
-     * Flag that indicates that this event was generated while redoing.
-     */
-    readonly isRedoing: boolean;
-}
-/**
- * A stored file based `IWorkingCopy` is backed by a `URI` from a
- * known file system provider. Given this assumption, a lot
- * of functionality can be built on top, such as saving in
- * a secure way to prevent data loss.
- */
-interface IStoredFileWorkingCopy<M extends IStoredFileWorkingCopyModel> extends IResourceWorkingCopy, IFileWorkingCopy<M> {
-    /**
-     * An event for when a stored file working copy was resolved.
-     */
-    readonly onDidResolve: Event<void>;
-    /**
-     * An event for when a stored file working copy was saved successfully.
-     */
-    readonly onDidSave: Event<IStoredFileWorkingCopySaveEvent>;
-    /**
-     * An event indicating that a stored file working copy save operation failed.
-     */
-    readonly onDidSaveError: Event<void>;
-    /**
-     * An event for when the readonly state of the stored file working copy changes.
-     */
-    readonly onDidChangeReadonly: Event<void>;
-    /**
-     * Resolves a stored file working copy.
-     */
-    resolve(options?: IStoredFileWorkingCopyResolveOptions): Promise<void>;
-    /**
-     * Explicitly sets the working copy to be modified.
-     */
-    markModified(): void;
-    /**
-     * Whether the stored file working copy is in the provided `state`
-     * or not.
-     *
-     * @param state the `FileWorkingCopyState` to check on.
-     */
-    hasState(state: StoredFileWorkingCopyState): boolean;
-    /**
-     * Allows to join a state change away from the provided `state`.
-     *
-     * @param state currently only `FileWorkingCopyState.PENDING_SAVE`
-     * can be awaited on to resolve.
-     */
-    joinState(state: StoredFileWorkingCopyState.PENDING_SAVE): Promise<void>;
-    /**
-     * Whether we have a resolved model or not.
-     */
-    isResolved(): this is IResolvedStoredFileWorkingCopy<M>;
-    /**
-     * Whether the stored file working copy is readonly or not.
-     */
-    isReadonly(): boolean;
-}
-interface IResolvedStoredFileWorkingCopy<M extends IStoredFileWorkingCopyModel> extends IStoredFileWorkingCopy<M> {
-    /**
-     * A resolved stored file working copy has a resolved model.
-     */
-    readonly model: M;
-}
-/**
- * States the stored file working copy can be in.
- */
-declare const enum StoredFileWorkingCopyState {
-    /**
-     * A stored file working copy is saved.
-     */
-    SAVED = 0,
-    /**
-     * A stored file working copy is dirty.
-     */
-    DIRTY = 1,
-    /**
-     * A stored file working copy is currently being saved but
-     * this operation has not completed yet.
-     */
-    PENDING_SAVE = 2,
-    /**
-     * A stored file working copy is in conflict mode when changes
-     * cannot be saved because the underlying file has changed.
-     * Stored file working copies in conflict mode are always dirty.
-     */
-    CONFLICT = 3,
-    /**
-     * A stored file working copy is in orphan state when the underlying
-     * file has been deleted.
-     */
-    ORPHAN = 4,
-    /**
-     * Any error that happens during a save that is not causing
-     * the `StoredFileWorkingCopyState.CONFLICT` state.
-     * Stored file working copies in error mode are always dirty.
-     */
-    ERROR = 5
-}
-interface IStoredFileWorkingCopyResolveOptions {
-    /**
-     * The contents to use for the stored file working copy if known. If not
-     * provided, the contents will be retrieved from the underlying
-     * resource or backup if present.
-     *
-     * If contents are provided, the stored file working copy will be marked
-     * as dirty right from the beginning.
-     */
-    readonly contents?: VSBufferReadableStream;
-    /**
-     * Go to disk bypassing any cache of the stored file working copy if any.
-     */
-    readonly forceReadFromFile?: boolean;
-}
-interface IStoredFileWorkingCopySaveEvent extends IWorkingCopySaveEvent {
-    /**
-     * The resolved stat from the save operation.
-     */
-    readonly stat: IFileStatWithMetadata;
-}
-
-interface SourceTargetPair {
-    /**
-     * The source resource that is defined for move operations.
-     */
-    readonly source?: URI;
-    /**
-     * The target resource the event is about.
-     */
-    readonly target: URI;
-}
-interface IFileOperationUndoRedoInfo {
-    /**
-     * Id of the undo group that the file operation belongs to.
-     */
-    undoRedoGroupId?: number;
-    /**
-     * Flag indicates if the operation is an undo.
-     */
-    isUndoing?: boolean;
-}
-interface WorkingCopyFileEvent extends IWaitUntil {
-    /**
-     * An identifier to correlate the operation through the
-     * different event types (before, after, error).
-     */
-    readonly correlationId: number;
-    /**
-     * The file operation that is taking place.
-     */
-    readonly operation: FileOperation;
-    /**
-     * The array of source/target pair of files involved in given operation.
-     */
-    readonly files: readonly SourceTargetPair[];
-}
-interface IWorkingCopyFileOperationParticipant {
-    /**
-     * Participate in a file operation of working copies. Allows to
-     * change the working copies before they are being saved to disk.
-     */
-    participate(files: SourceTargetPair[], operation: FileOperation, undoInfo: IFileOperationUndoRedoInfo | undefined, timeout: number, token: CancellationToken): Promise<void>;
-}
-interface IStoredFileWorkingCopySaveParticipant {
-    /**
-     * Participate in a save operation of file stored working copies.
-     * Allows to make changes before content is being saved to disk.
-     */
-    participate(workingCopy: IStoredFileWorkingCopy<IStoredFileWorkingCopyModel>, context: {
-        reason: SaveReason;
-    }, progress: IProgress<IProgressStep>, token: CancellationToken): Promise<void>;
-}
-interface ICreateOperation {
-    resource: URI;
-    overwrite?: boolean;
-}
-interface ICreateFileOperation extends ICreateOperation {
-    contents?: VSBuffer | VSBufferReadable | VSBufferReadableStream;
-}
-interface IDeleteOperation {
-    resource: URI;
-    useTrash?: boolean;
-    recursive?: boolean;
-}
-interface IMoveOperation {
-    file: Required<SourceTargetPair>;
-    overwrite?: boolean;
+interface IElectricAction {
+    matchOpenBracket: string;
 }
-interface ICopyOperation extends IMoveOperation {
+declare class BracketElectricCharacterSupport {
+    private readonly _richEditBrackets;
+    constructor(richEditBrackets: RichEditBrackets | null);
+    getElectricCharacters(): string[];
+    onElectricCharacter(character: string, context: ScopedLineTokens, column: number): IElectricAction | null;
 }
-/**
- * Returns the working copies for a given resource.
- */
-type WorkingCopyProvider = (resourceOrFolder: URI) => IWorkingCopy[];
 
-declare const IWorkingCopyFileService: ServiceIdentifier<IWorkingCopyFileService>;
-/**
- * A service that allows to perform file operations with working copy support.
- * Any operation that would leave a stale dirty working copy behind will make
- * sure to revert the working copy first.
- *
- * On top of that events are provided to participate in each state of the
- * operation to perform additional work.
- */
-interface IWorkingCopyFileService {
-    readonly _serviceBrand: undefined;
-    /**
-     * An event that is fired when a certain working copy IO operation is about to run.
-     *
-     * Participants can join this event with a long running operation to keep some state
-     * before the operation is started, but working copies should not be changed at this
-     * point in time. For that purpose, use the `IWorkingCopyFileOperationParticipant` API.
-     */
-    readonly onWillRunWorkingCopyFileOperation: Event<WorkingCopyFileEvent>;
-    /**
-     * An event that is fired after a working copy IO operation has failed.
-     *
-     * Participants can join this event with a long running operation to clean up as needed.
-     */
-    readonly onDidFailWorkingCopyFileOperation: Event<WorkingCopyFileEvent>;
-    /**
-     * An event that is fired after a working copy IO operation has been performed.
-     *
-     * Participants can join this event with a long running operation to make changes
-     * after the operation has finished.
-     */
-    readonly onDidRunWorkingCopyFileOperation: Event<WorkingCopyFileEvent>;
-    /**
-     * Adds a participant for file operations on working copies.
-     */
-    addFileOperationParticipant(participant: IWorkingCopyFileOperationParticipant): IDisposable;
-    /**
-     * Whether save participants are present for stored file working copies.
-     */
-    get hasSaveParticipants(): boolean;
-    /**
-     * Adds a participant for save operations on stored file working copies.
-     */
-    addSaveParticipant(participant: IStoredFileWorkingCopySaveParticipant): IDisposable;
-    /**
-     * Runs all available save participants for stored file working copies.
-     */
-    runSaveParticipants(workingCopy: IStoredFileWorkingCopy<IStoredFileWorkingCopyModel>, context: {
-        reason: SaveReason;
-    }, token: CancellationToken): Promise<void>;
-    /**
-     * Will create a resource with the provided optional contents, optionally overwriting any target.
-     *
-     * Working copy owners can listen to the `onWillRunWorkingCopyFileOperation` and
-     * `onDidRunWorkingCopyFileOperation` events to participate.
-     */
-    create(operations: ICreateFileOperation[], token: CancellationToken, undoInfo?: IFileOperationUndoRedoInfo): Promise<readonly IFileStatWithMetadata[]>;
-    /**
-     * Will create a folder and any parent folder that needs to be created.
-     *
-     * Working copy owners can listen to the `onWillRunWorkingCopyFileOperation` and
-     * `onDidRunWorkingCopyFileOperation` events to participate.
-     *
-     * Note: events will only be emitted for the provided resource, but not any
-     * parent folders that are being created as part of the operation.
-     */
-    createFolder(operations: ICreateOperation[], token: CancellationToken, undoInfo?: IFileOperationUndoRedoInfo): Promise<readonly IFileStatWithMetadata[]>;
-    /**
-     * Will move working copies matching the provided resources and corresponding children
-     * to the target resources using the associated file service for those resources.
-     *
-     * Working copy owners can listen to the `onWillRunWorkingCopyFileOperation` and
-     * `onDidRunWorkingCopyFileOperation` events to participate.
-     */
-    move(operations: IMoveOperation[], token: CancellationToken, undoInfo?: IFileOperationUndoRedoInfo): Promise<readonly IFileStatWithMetadata[]>;
-    /**
-     * Will copy working copies matching the provided resources and corresponding children
-     * to the target resources using the associated file service for those resources.
-     *
-     * Working copy owners can listen to the `onWillRunWorkingCopyFileOperation` and
-     * `onDidRunWorkingCopyFileOperation` events to participate.
-     */
-    copy(operations: ICopyOperation[], token: CancellationToken, undoInfo?: IFileOperationUndoRedoInfo): Promise<readonly IFileStatWithMetadata[]>;
-    /**
-     * Will delete working copies matching the provided resources and children
-     * using the associated file service for those resources.
-     *
-     * Working copy owners can listen to the `onWillRunWorkingCopyFileOperation` and
-     * `onDidRunWorkingCopyFileOperation` events to participate.
-     */
-    delete(operations: IDeleteOperation[], token: CancellationToken, undoInfo?: IFileOperationUndoRedoInfo): Promise<void>;
-    /**
-     * Register a new provider for working copies based on a resource.
-     *
-     * @return a disposable that unregisters the provider.
-     */
-    registerWorkingCopyProvider(provider: WorkingCopyProvider): IDisposable;
-    /**
-     * Will return all working copies that are dirty matching the provided resource.
-     * If the resource is a folder and the scheme supports file operations, a working
-     * copy that is dirty and is a child of that folder will also be returned.
-     */
-    getDirty(resource: URI): readonly IWorkingCopy[];
+declare class IndentRulesSupport {
+    private readonly _indentationRules;
+    constructor(indentationRules: IndentationRule);
+    shouldIncrease(text: string): boolean;
+    shouldDecrease(text: string): boolean;
+    shouldIndentNextLine(text: string): boolean;
+    shouldIgnore(text: string): boolean;
+    getIndentMetadata(text: string): number;
 }
 
-declare const ITextFileService: ServiceIdentifier<ITextFileService>;
-interface ITextFileService extends IDisposable {
-    readonly _serviceBrand: undefined;
-    /**
-     * Access to the manager of text file editor models providing further
-     * methods to work with them.
-     */
-    readonly files: ITextFileEditorModelManager;
-    /**
-     * Access to the manager of untitled text editor models providing further
-     * methods to work with them.
-     */
-    readonly untitled: IUntitledTextEditorModelManager;
-    /**
-     * Helper to determine encoding for resources.
-     */
-    readonly encoding: IResourceEncodings;
-    /**
-     * A resource is dirty if it has unsaved changes or is an untitled file not yet saved.
-     *
-     * @param resource the resource to check for being dirty
-     */
-    isDirty(resource: URI): boolean;
-    /**
-     * Saves the resource.
-     *
-     * @param resource the resource to save
-     * @param options optional save options
-     * @return Path of the saved resource or undefined if canceled.
-     */
-    save(resource: URI, options?: ITextFileSaveOptions): Promise<URI | undefined>;
-    /**
-     * Saves the provided resource asking the user for a file name or using the provided one.
-     *
-     * @param resource the resource to save as.
-     * @param targetResource the optional target to save to.
-     * @param options optional save options
-     * @return Path of the saved resource or undefined if canceled.
-     */
-    saveAs(resource: URI, targetResource?: URI, options?: ITextFileSaveAsOptions): Promise<URI | undefined>;
-    /**
-     * Reverts the provided resource.
-     *
-     * @param resource the resource of the file to revert.
-     * @param force to force revert even when the file is not dirty
-     */
-    revert(resource: URI, options?: IRevertOptions): Promise<void>;
-    /**
-     * Read the contents of a file identified by the resource.
-     */
-    read(resource: URI, options?: IReadTextFileOptions): Promise<ITextFileContent>;
-    /**
-     * Read the contents of a file identified by the resource as stream.
-     */
-    readStream(resource: URI, options?: IReadTextFileOptions): Promise<ITextFileStreamContent>;
-    /**
-     * Update a file with given contents.
-     */
-    write(resource: URI, value: string | ITextSnapshot, options?: IWriteTextFileOptions): Promise<IFileStatWithMetadata>;
-    /**
-     * Create files. If the file exists it will be overwritten with the contents if
-     * the options enable to overwrite.
-     */
-    create(operations: {
-        resource: URI;
-        value?: string | ITextSnapshot;
-        options?: {
-            overwrite?: boolean;
-        };
-    }[], undoInfo?: IFileOperationUndoRedoInfo): Promise<readonly IFileStatWithMetadata[]>;
-    /**
-     * Returns the readable that uses the appropriate encoding. This method should
-     * be used whenever a `string` or `ITextSnapshot` is being persisted to the
-     * file system.
-     */
-    getEncodedReadable(resource: URI, value: ITextSnapshot, options?: IWriteTextFileOptions): Promise<VSBufferReadable>;
-    getEncodedReadable(resource: URI, value: string, options?: IWriteTextFileOptions): Promise<VSBuffer>;
-    getEncodedReadable(resource: URI, value?: ITextSnapshot, options?: IWriteTextFileOptions): Promise<VSBufferReadable | undefined>;
-    getEncodedReadable(resource: URI, value?: string, options?: IWriteTextFileOptions): Promise<VSBuffer | undefined>;
-    getEncodedReadable(resource: URI, value?: string | ITextSnapshot, options?: IWriteTextFileOptions): Promise<VSBuffer | VSBufferReadable | undefined>;
-    /**
-     * Returns a stream of strings that uses the appropriate encoding. This method should
-     * be used whenever a `VSBufferReadableStream` is being loaded from the file system.
-     *
-     * Will throw an error if `acceptTextOnly: true` for resources that seem to be binary.
-     */
-    getDecodedStream(resource: URI, value: VSBufferReadableStream, options?: IReadTextFileEncodingOptions): Promise<ReadableStream<string>>;
-}
-interface IReadTextFileEncodingOptions {
-    /**
-     * The optional encoding parameter allows to specify the desired encoding when resolving
-     * the contents of the file.
-     */
-    readonly encoding?: string;
-    /**
-     * The optional guessEncoding parameter allows to guess encoding from content of the file.
-     */
-    readonly autoGuessEncoding?: boolean;
-    /**
-     * The optional acceptTextOnly parameter allows to fail this request early if the file
-     * contents are not textual.
-     */
-    readonly acceptTextOnly?: boolean;
-}
-interface IReadTextFileOptions extends IReadTextFileEncodingOptions, IReadFileStreamOptions {
-}
-interface IWriteTextFileOptions extends IWriteFileOptions {
-    /**
-     * The encoding to use when updating a file.
-     */
-    readonly encoding?: string;
-    /**
-     * Whether to write to the file as elevated (admin) user. When setting this option a prompt will
-     * ask the user to authenticate as super user.
-     */
-    readonly writeElevated?: boolean;
-}
-interface IResourceEncodings {
-    getPreferredReadEncoding(resource: URI): Promise<IResourceEncoding>;
-    getPreferredWriteEncoding(resource: URI, preferredEncoding?: string): Promise<IResourceEncoding>;
-}
-interface IResourceEncoding {
-    readonly encoding: string;
-    readonly hasBOM: boolean;
-}
 /**
- * The save error handler can be installed on the text file editor model to install code that executes when save errors occur.
- */
-interface ISaveErrorHandler {
-    /**
-     * Called whenever a save fails.
-     */
-    onSaveError(error: Error, model: ITextFileEditorModel): void;
-}
-/**
- * States the text file editor model can be in.
+ * Interface used to support insertion of mode specific comments.
  */
-declare const enum TextFileEditorModelState {
-    /**
-     * A model is saved.
-     */
-    SAVED = 0,
-    /**
-     * A model is dirty.
-     */
-    DIRTY = 1,
-    /**
-     * A model is currently being saved but this operation has not completed yet.
-     */
-    PENDING_SAVE = 2,
-    /**
-     * A model is in conflict mode when changes cannot be saved because the
-     * underlying file has changed. Models in conflict mode are always dirty.
-     */
-    CONFLICT = 3,
-    /**
-     * A model is in orphan state when the underlying file has been deleted.
-     */
-    ORPHAN = 4,
-    /**
-     * Any error that happens during a save that is not causing the CONFLICT state.
-     * Models in error mode are always dirty.
-     */
-    ERROR = 5
-}
-declare const enum TextFileResolveReason {
-    EDITOR = 1,
-    REFERENCE = 2,
-    OTHER = 3
-}
-interface IBaseTextFileContent extends IBaseFileStatWithMetadata {
-    /**
-     * The encoding of the content if known.
-     */
-    readonly encoding: string;
-}
-interface ITextFileContent extends IBaseTextFileContent {
-    /**
-     * The content of a text file.
-     */
-    readonly value: string;
-}
-interface ITextFileStreamContent extends IBaseTextFileContent {
-    /**
-     * The line grouped content of a text file.
-     */
-    readonly value: ITextBufferFactory;
-}
-interface ITextFileEditorModelResolveOrCreateOptions extends ITextFileResolveOptions {
-    /**
-     * The language id to use for the model text content.
-     */
-    readonly languageId?: string;
-    /**
-     * The encoding to use when resolving the model text content.
-     */
-    readonly encoding?: string;
-    /**
-     * If the model was already resolved before, allows to trigger
-     * a reload of it to fetch the latest contents.
-     */
-    readonly reload?: {
-        /**
-         * Controls whether the reload happens in the background
-         * or whether `resolve` will await the reload to happen.
-         */
-        readonly async: boolean;
-    };
-}
-interface ITextFileSaveEvent extends ITextFileEditorModelSaveEvent {
-    /**
-     * The model that was saved.
-     */
-    readonly model: ITextFileEditorModel;
-}
-interface ITextFileResolveEvent {
-    /**
-     * The model that was resolved.
-     */
-    readonly model: ITextFileEditorModel;
-    /**
-     * The reason why the model was resolved.
-     */
-    readonly reason: TextFileResolveReason;
-}
-interface ITextFileSaveParticipant {
-    /**
-     * Participate in a save of a model. Allows to change the model
-     * before it is being saved to disk.
-     */
-    participate(model: ITextFileEditorModel, context: {
-        reason: SaveReason;
-    }, progress: IProgress<IProgressStep>, token: CancellationToken): Promise<void>;
-}
-interface ITextFileEditorModelManager {
-    readonly onDidCreate: Event<ITextFileEditorModel>;
-    readonly onDidResolve: Event<ITextFileResolveEvent>;
-    readonly onDidChangeDirty: Event<ITextFileEditorModel>;
-    readonly onDidChangeReadonly: Event<ITextFileEditorModel>;
-    readonly onDidRemove: Event<URI>;
-    readonly onDidChangeOrphaned: Event<ITextFileEditorModel>;
-    readonly onDidChangeEncoding: Event<ITextFileEditorModel>;
-    readonly onDidSaveError: Event<ITextFileEditorModel>;
-    readonly onDidSave: Event<ITextFileSaveEvent>;
-    readonly onDidRevert: Event<ITextFileEditorModel>;
-    /**
-     * Access to all text file editor models in memory.
-     */
-    readonly models: ITextFileEditorModel[];
-    /**
-     * Allows to configure the error handler that is called on save errors.
-     */
-    saveErrorHandler: ISaveErrorHandler;
-    /**
-     * Returns the text file editor model for the provided resource
-     * or undefined if none.
-     */
-    get(resource: URI): ITextFileEditorModel | undefined;
-    /**
-     * Allows to resolve a text file model from disk.
-     */
-    resolve(resource: URI, options?: ITextFileEditorModelResolveOrCreateOptions): Promise<ITextFileEditorModel>;
-    /**
-     * Adds a participant for saving text file models.
-     */
-    addSaveParticipant(participant: ITextFileSaveParticipant): IDisposable;
-    /**
-     * Runs the registered save participants on the provided model.
-     */
-    runSaveParticipants(model: ITextFileEditorModel, context: {
-        reason: SaveReason;
-    }, token: CancellationToken): Promise<void>;
-    /**
-     * Waits for the model to be ready to be disposed. There may be conditions
-     * under which the model cannot be disposed, e.g. when it is dirty. Once the
-     * promise is settled, it is safe to dispose the model.
-     */
-    canDispose(model: ITextFileEditorModel): true | Promise<true>;
-}
-interface ITextFileSaveOptions extends ISaveOptions {
-    /**
-     * Save the file with an attempt to unlock it.
-     */
-    readonly writeUnlock?: boolean;
-    /**
-     * Save the file with elevated privileges.
-     *
-     * Note: This may not be supported in all environments.
-     */
-    readonly writeElevated?: boolean;
-    /**
-     * Allows to write to a file even if it has been modified on disk.
-     */
-    readonly ignoreModifiedSince?: boolean;
-    /**
-     * If set, will bubble up the error to the caller instead of handling it.
-     */
-    readonly ignoreErrorHandler?: boolean;
-}
-interface ITextFileSaveAsOptions extends ITextFileSaveOptions {
-    /**
-     * Optional URI to use as suggested file path to save as.
-     */
-    readonly suggestedTarget?: URI;
-}
-interface ITextFileResolveOptions {
-    /**
-     * The contents to use for the model if known. If not
-     * provided, the contents will be retrieved from the
-     * underlying resource or backup if present.
-     */
-    readonly contents?: ITextBufferFactory;
-    /**
-     * Go to file bypassing any cache of the model if any.
-     */
-    readonly forceReadFromFile?: boolean;
-    /**
-     * Allow to resolve a model even if we think it is a binary file.
-     */
-    readonly allowBinary?: boolean;
-    /**
-     * Context why the model is being resolved.
-     */
-    readonly reason?: TextFileResolveReason;
-    /**
-     * If provided, the size of the file will be checked against the limits
-     * and an error will be thrown if any limit is exceeded.
-     */
-    readonly limits?: IFileReadLimits;
-}
-declare const enum EncodingMode {
-    /**
-     * Instructs the encoding support to encode the object with the provided encoding
-     */
-    Encode = 0,
-    /**
-     * Instructs the encoding support to decode the object with the provided encoding
-     */
-    Decode = 1
-}
-interface IEncodingSupport {
-    /**
-     * Gets the encoding of the object if known.
-     */
-    getEncoding(): string | undefined;
-    /**
-     * Sets the encoding for the object for saving.
-     */
-    setEncoding(encoding: string, mode: EncodingMode): Promise<void>;
+interface ICommentsConfiguration {
+    lineCommentToken?: string;
+    blockCommentStartToken?: string;
+    blockCommentEndToken?: string;
 }
-interface ILanguageSupport {
-    /**
-     * Sets the language id of the object.
-     */
-    setLanguageId(languageId: string, source?: string): void;
+declare class LanguageConfigurationServiceChangeEvent {
+    readonly languageId: string | undefined;
+    constructor(languageId: string | undefined);
+    affects(languageId: string): boolean;
 }
-interface ITextFileEditorModelSaveEvent extends IWorkingCopySaveEvent {
+interface ILanguageConfigurationService {
+    readonly _serviceBrand: undefined;
+    onDidChange: Event<LanguageConfigurationServiceChangeEvent>;
     /**
-     * The resolved stat from the save operation.
+     * @param priority Use a higher number for higher priority
      */
-    readonly stat: IFileStatWithMetadata;
-}
-interface ITextFileEditorModel extends ITextEditorModel, IEncodingSupport, ILanguageSupport, IWorkingCopy {
-    readonly onDidSave: Event<ITextFileEditorModelSaveEvent>;
-    readonly onDidSaveError: Event<void>;
-    readonly onDidChangeOrphaned: Event<void>;
-    readonly onDidChangeReadonly: Event<void>;
-    readonly onDidChangeEncoding: Event<void>;
-    hasState(state: TextFileEditorModelState): boolean;
-    joinState(state: TextFileEditorModelState.PENDING_SAVE): Promise<void>;
-    updatePreferredEncoding(encoding: string | undefined): void;
-    save(options?: ITextFileSaveOptions): Promise<boolean>;
-    revert(options?: IRevertOptions): Promise<void>;
-    resolve(options?: ITextFileResolveOptions): Promise<void>;
-    isDirty(): this is IResolvedTextFileEditorModel;
-    getLanguageId(): string | undefined;
-    isResolved(): this is IResolvedTextFileEditorModel;
-}
-interface IResolvedTextFileEditorModel extends ITextFileEditorModel {
-    readonly textEditorModel: ITextModel;
-    createSnapshot(): ITextSnapshot;
-}
-
-type ColorIdentifier = string;
-declare const enum ColorTransformType {
-    Darken = 0,
-    Lighten = 1,
-    Transparent = 2,
-    Opaque = 3,
-    OneOf = 4,
-    LessProminent = 5,
-    IfDefinedThenElse = 6
-}
-type ColorTransform = {
-    op: ColorTransformType.Darken;
-    value: ColorValue;
-    factor: number;
-} | {
-    op: ColorTransformType.Lighten;
-    value: ColorValue;
-    factor: number;
-} | {
-    op: ColorTransformType.Transparent;
-    value: ColorValue;
-    factor: number;
-} | {
-    op: ColorTransformType.Opaque;
-    value: ColorValue;
-    background: ColorValue;
-} | {
-    op: ColorTransformType.OneOf;
-    values: readonly ColorValue[];
-} | {
-    op: ColorTransformType.LessProminent;
-    value: ColorValue;
-    background: ColorValue;
-    factor: number;
-    transparency: number;
-} | {
-    op: ColorTransformType.IfDefinedThenElse;
-    if: ColorIdentifier;
-    then: ColorValue;
-    else: ColorValue;
-};
-interface ColorDefaults {
-    light: ColorValue | null;
-    dark: ColorValue | null;
-    hcDark: ColorValue | null;
-    hcLight: ColorValue | null;
+    register(languageId: string, configuration: LanguageConfiguration, priority?: number): IDisposable;
+    getLanguageConfiguration(languageId: string): ResolvedLanguageConfiguration;
 }
+declare const ILanguageConfigurationService: ServiceIdentifier<ILanguageConfigurationService>;
 /**
- * A Color Value is either a color literal, a reference to an other color or a derived color
- */
-type ColorValue = Color | string | ColorIdentifier | ColorTransform;
-declare function registerColor(id: string, defaults: ColorDefaults | null, description: string, needsTransparency?: boolean, deprecationMessage?: string): ColorIdentifier;
+ * Immutable.
+*/
+declare class ResolvedLanguageConfiguration {
+    readonly languageId: string;
+    readonly underlyingConfig: LanguageConfiguration;
+    private _brackets;
+    private _electricCharacter;
+    private readonly _onEnterSupport;
+    readonly comments: ICommentsConfiguration | null;
+    readonly characterPair: CharacterPairSupport;
+    readonly wordDefinition: RegExp;
+    readonly indentRulesSupport: IndentRulesSupport | null;
+    readonly indentationRules: IndentationRule | undefined;
+    readonly foldingRules: FoldingRules;
+    readonly bracketsNew: LanguageBracketsConfiguration;
+    constructor(languageId: string, underlyingConfig: LanguageConfiguration);
+    getWordDefinition(): RegExp;
+    get brackets(): RichEditBrackets | null;
+    get electricCharacter(): BracketElectricCharacterSupport | null;
+    onEnter(autoIndent: EditorAutoIndentStrategy, previousLineText: string, beforeEnterText: string, afterEnterText: string): EnterAction | null;
+    getAutoClosingPairs(): AutoClosingPairs;
+    getAutoCloseBeforeSet(forQuotes: boolean): string;
+    getSurroundingPairs(): IAutoClosingPair[];
+    private static _handleComments;
+}
 
 interface LanguageFilter {
     readonly language?: string;
@@ -3780,4 +654,4 @@ interface ILanguageFeaturesService {
     setNotebookTypeResolver(resolver: NotebookInfoResolver | undefined): void;
 }
 
-export { INotificationHandle as A, IPromptChoice as B, CommandsRegistry as C, IPromptChoiceWithMenu as D, IPromptOptions as E, FoldingRangeProvider as F, IStatusMessageOptions as G, NoOpNotification as H, ILanguageFeaturesService as I, NoOpProgress as J, LanguageFeatureRegistry as L, NotificationsFilter as N, SubmenuAction as S, TextEdit as T, WorkspaceEdit as W, ILanguageConfigurationService as a, INotificationService as b, ITextFileEditorModel as c, ILanguageIdCodec as d, IAction as e, ICommandService as f, ColorIdentifier as g, Color as h, LanguageSelector as i, Command as j, IInplaceReplaceSupportResult as k, WorkspaceEditMetadata as l, IActionRunner as m, IMarkerService as n, ITextFileService as o, IWorkingCopyFileService as p, NotificationMessage as q, registerColor as r, NotificationPriority as s, INotificationProperties as t, NeverShowAgainScope as u, INeverShowAgainOptions as v, INotification as w, INotificationActions as x, INotificationProgress as y, INotificationProgressProperties as z };
+export { ILanguageFeaturesService as I, LanguageFeatureRegistry as L, ILanguageConfigurationService as a, LanguageSelector as b };