@codingame/monaco-vscode-api 1.78.8 → 1.79.0

package/dist/languageFeatures.d.ts

@@ -0,0 +1,4762 @@
+import { S as ServiceIdentifier, I as IInstantiationService } from './instantiation.js';
+import { E as Event, C as CancellationToken, I as IDisposable, b as Emitter, d as IWaitUntil, D as Disposable } from './event.js';
+import { a as ITextModel, P as Position, R as Range, S as Selection, e as IRange, E as EndOfLineSequence, f as IPosition, s as ISingleEditOperation, t as EditorAutoIndentStrategy, u as IDimension, v as ITextEditorModel, w as ITextSnapshot, I as ITextBufferFactory, d as IDiffEditor } from './editorBrowser.js';
+import { U as URI } from './uri.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 { I as IProgress, a as IProgressStep, w as IComposite, z as ICompositeControl } from './colorRegistry.js';
+import { I as IMarkdownString, c as IEditorOptions, e as IEditorModel, f as IBaseTextResourceEditorInput, g as IBaseUntypedEditorInput, a as IResourceEditorInput, b as ITextResourceEditorInput } from './editor.js';
+import { I as IContextKeyService } from './contextkey.js';
+import { T as ThemeIcon } from './themables.js';
+import { S as Severity, E as ExtensionIdentifier } from './extensions.d2.ts';
+
+interface IDataTransferFile {
+    readonly name: string;
+    readonly uri?: URI;
+    data(): Promise<Uint8Array>;
+}
+interface IDataTransferItem {
+    readonly id: string;
+    asString(): Thenable<string>;
+    asFile(): IDataTransferFile | undefined;
+    value: any;
+}
+declare class VSDataTransfer {
+    private readonly _entries;
+    /**
+     * Get the total number of entries in this data transfer.
+     */
+    get size(): number;
+    /**
+     * Check if this data transfer contains data for `mimeType`.
+     *
+     * This uses exact matching and does not support wildcards.
+     */
+    has(mimeType: string): boolean;
+    /**
+     * Check if this data transfer contains data matching `mimeTypeGlob`.
+     *
+     * This allows matching for wildcards, such as `image/*`.
+     *
+     * Use the special `files` mime type to match any file in the data transfer.
+     */
+    matches(mimeTypeGlob: string): boolean;
+    /**
+     * Retrieve the first entry for `mimeType`.
+     *
+     * Note that if want to find all entries for a given mime type, use {@link VSDataTransfer.entries} instead.
+     */
+    get(mimeType: string): IDataTransferItem | undefined;
+    /**
+     * Add a new entry to this data transfer.
+     *
+     * This does not replace existing entries for `mimeType`.
+     */
+    append(mimeType: string, value: IDataTransferItem): void;
+    /**
+     * Set the entry for a given mime type.
+     *
+     * This replaces all existing entries for `mimeType`.
+     */
+    replace(mimeType: string, value: IDataTransferItem): void;
+    /**
+     * Remove all entries for `mimeType`.
+     */
+    delete(mimeType: string): void;
+    /**
+     * Iterate over all `[mime, item]` pairs in this data transfer.
+     *
+     * There may be multiple entries for each mime type.
+     */
+    entries(): Iterable<[string, IDataTransferItem]>;
+    /**
+     * Iterate over all items in this data transfer.
+     *
+     * There may be multiple entries for each mime type.
+     */
+    values(): Iterable<IDataTransferItem>;
+    /**
+     * Call `f` for each item and mime in the data transfer.
+     *
+     * There may be multiple entries for each mime type.
+     */
+    forEach(f: (value: IDataTransferItem, mime: string) => void): void;
+    private toKey;
+}
+
+/**
+ * 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): MarkerSeverity;
+    function toSeverity(severity: MarkerSeverity): Severity;
+}
+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[]>;
+}
+declare const IMarkerService: ServiceIdentifier<IMarkerService>;
+
+/**
+ * @internal
+ */
+interface ILanguageIdCodec {
+    encodeLanguageId(languageId: string): LanguageId;
+    decodeLanguageId(languageId: LanguageId): string;
+}
+/**
+ * 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.
+ */
+interface Hover {
+    /**
+     * The contents of this hover.
+     */
+    contents: IMarkdownString[];
+    /**
+     * The range to which this hover applies. When missing, the
+     * editor will use the range at the current position or the
+     * current position itself.
+     */
+    range?: IRange;
+}
+/**
+ * The hover provider interface defines the contract between extensions and
+ * the [hover](https://code.visualstudio.com/docs/editor/intellisense)-feature.
+ */
+interface HoverProvider {
+    /**
+     * 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.
+     */
+    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 {
+    /**
+     * The range to which this expression applies.
+     */
+    range: IRange;
+    /**
+     * This expression overrides the expression extracted from the range.
+     */
+    expression?: string;
+}
+/**
+ * The evaluatable expression provider interface defines the contract between extensions and
+ * the debug hover.
+ * @internal
+ */
+interface EvaluatableExpressionProvider {
+    /**
+     * 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.
+     */
+    provideEvaluatableExpression(model: ITextModel, position: Position, token: CancellationToken): ProviderResult<EvaluatableExpression>;
+}
+/**
+ * A value-object that contains contextual information when requesting inline values from a InlineValuesProvider.
+ * @internal
+ */
+interface InlineValueContext {
+    frameId: number;
+    stoppedLocation: Range;
+}
+/**
+ * Provide inline value as text.
+ * @internal
+ */
+interface InlineValueText {
+    type: 'text';
+    range: IRange;
+    text: string;
+}
+/**
+ * Provide inline value through a variable lookup.
+ * @internal
+ */
+interface InlineValueVariableLookup {
+    type: 'variable';
+    range: IRange;
+    variableName?: string;
+    caseSensitiveLookup: boolean;
+}
+/**
+ * Provide inline value through an expression evaluation.
+ * @internal
+ */
+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 {
+    /**
+     */
+    onDidChangeInlineValues?: Event<void> | undefined;
+    /**
+     * 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.
+     */
+    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,
+    /**
+     * Adjust whitespace/indentation of multiline insert texts to
+     * match the current line indentation.
+     */
+    KeepWhitespace = 1,
+    /**
+     * `insertText` is a snippet.
+     */
+    InsertAsSnippet = 4
+}
+interface CompletionItemRanges {
+    insert: IRange;
+    replace: IRange;
+}
+/**
+ * A completion item represents a text snippet that is
+ * proposed to complete text that is being typed.
+ */
+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;
+    /**
+     * A string or snippet that should be inserted in a document when selecting
+     * this completion.
+     */
+    insertText: string;
+    /**
+     * Additional rules (as bitmask) that should be applied when inserting
+     * this completion.
+     */
+    insertTextRules?: CompletionItemInsertTextRule;
+    /**
+     * 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}.
+     */
+    range: IRange | CompletionItemRanges;
+    /**
+     * 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.
+     */
+    commitCharacters?: string[];
+    /**
+     * An optional array of additional text edits that are applied when
+     * selecting this completion. Edits must not overlap with the main edit
+     * nor with themselves.
+     */
+    additionalTextEdits?: ISingleEditOperation[];
+    /**
+     * A command that should be run upon acceptance of this item.
+     */
+    command?: Command;
+    /**
+     * @internal
+     */
+    extensionId?: ExtensionIdentifier;
+    /**
+     * @internal
+     */
+    _id?: [number, number];
+}
+interface CompletionList {
+    suggestions: CompletionItem[];
+    incomplete?: boolean;
+    dispose?(): void;
+    /**
+     * @internal
+     */
+    duration?: number;
+}
+/**
+ * How a suggest provider was triggered.
+ */
+declare const enum CompletionTriggerKind {
+    Invoke = 0,
+    TriggerCharacter = 1,
+    TriggerForIncompleteCompletions = 2
+}
+/**
+ * Contains additional information about the context in which
+ * {@link CompletionItemProvider.provideCompletionItems completion provider} is triggered.
+ */
+interface CompletionContext {
+    /**
+     * How the completion was triggered.
+     */
+    triggerKind: CompletionTriggerKind;
+    /**
+     * Character that triggered the completion item provider.
+     *
+     * `undefined` if provider was not triggered by a character.
+     */
+    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 {
+    /**
+     * @internal
+     */
+    _debugDisplayName?: string;
+    triggerCharacters?: string[];
+    /**
+     * Provide completion items for the given position and document.
+     */
+    provideCompletionItems(model: ITextModel, position: Position, context: CompletionContext, token: CancellationToken): ProviderResult<CompletionList>;
+    /**
+     * Given a completion item fill in more data, like {@link CompletionItem.documentation doc-comment}
+     * or {@link CompletionItem.detail details}.
+     *
+     * The editor will only resolve a completion item once.
+     */
+    resolveCompletionItem?(item: CompletionItem, token: CancellationToken): ProviderResult<CompletionItem>;
+}
+/**
+ * How an {@link InlineCompletionsProvider inline completion provider} was triggered.
+ */
+declare enum InlineCompletionTriggerKind {
+    /**
+     * Completion was triggered automatically while editing.
+     * It is sufficient to return a single completion item in this case.
+     */
+    Automatic = 0,
+    /**
+     * Completion was triggered explicitly by a user gesture.
+     * Return multiple completion items to enable cycling through them.
+     */
+    Explicit = 1
+}
+interface InlineCompletionContext {
+    /**
+     * How the completion was triggered.
+     */
+    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 {
+    /**
+     * The text to insert.
+     * If the text contains a line break, the range must end at the end of a line.
+     * If existing text should be replaced, the existing text must be a prefix of the text to insert.
+     *
+     * The text can also be a snippet. In that case, a preview with default parameters is shown.
+     * When accepting the suggestion, the full snippet is inserted.
+    */
+    readonly insertText: string | {
+        snippet: string;
+    };
+    /**
+     * A text that is used to decide if this inline completion should be shown.
+     * An inline completion is shown if the text to replace is a subword of the filter text.
+     */
+    readonly filterText?: string;
+    /**
+     * An optional array of additional text edits that are applied when
+     * selecting this completion. Edits must not overlap with the main edit
+     * nor with themselves.
+     */
+    readonly additionalTextEdits?: 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[];
+    /**
+     * A list of commands associated with the inline completions of this list.
+     */
+    readonly commands?: Command[];
+    readonly suppressSuggestions?: boolean | undefined;
+    /**
+     * When set and the user types a suggestion without derivating from it, the inline suggestion is not updated.
+     */
+    readonly enableForwardStability?: boolean | undefined;
+}
+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;
+    /**
+     * Will be called when an item is partially accepted.
+     */
+    handlePartialAccept?(completions: T, item: T['items'][number], acceptedCharacters: number): void;
+    /**
+     * Will be called when a completions list is no longer in use and can be garbage-collected.
+    */
+    freeInlineCompletions(completions: T): void;
+}
+interface CodeAction {
+    title: string;
+    command?: Command;
+    edit?: WorkspaceEdit;
+    diagnostics?: IMarkerData[];
+    kind?: string;
+    isPreferred?: boolean;
+    disabled?: string;
+}
+declare const enum CodeActionTriggerType {
+    Invoke = 1,
+    Auto = 2
+}
+/**
+ * @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 {
+    insertText: string | {
+        snippet: string;
+    };
+    additionalEdit?: WorkspaceEdit;
+}
+/**
+ * @internal
+ */
+interface DocumentPasteEditProvider {
+    readonly pasteMimeTypes: readonly string[];
+    prepareDocumentPaste?(model: ITextModel, ranges: readonly IRange[], dataTransfer: VSDataTransfer, token: CancellationToken): Promise<undefined | VSDataTransfer>;
+    provideDocumentPasteEdits(model: ITextModel, ranges: readonly IRange[], dataTransfer: VSDataTransfer, 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 label: string;
+    insertText: string | {
+        snippet: string;
+    };
+    additionalEdit?: WorkspaceEdit;
+}
+/**
+ * @internal
+ */
+interface DocumentOnDropEditProvider {
+    readonly id: string;
+    readonly dropMimeTypes?: readonly string[];
+    provideDocumentOnDropEdits(model: ITextModel, position: IPosition, dataTransfer: VSDataTransfer, 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 IDialogArgs {
+    readonly confirmArgs?: IConfirmDialogArgs;
+    readonly inputArgs?: IInputDialogArgs;
+    readonly promptArgs?: IPromptDialogArgs;
+}
+interface IBaseDialogOptions {
+    readonly type?: Severity | DialogType;
+    readonly title?: string;
+    readonly message: string;
+    readonly detail?: string;
+    readonly checkbox?: ICheckbox;
+    /**
+     * Allows to enforce use of custom dialog even in native environments.
+     */
+    readonly custom?: boolean | ICustomDialogOptions;
+}
+interface IConfirmDialogArgs {
+    readonly confirmation: IConfirmation;
+}
+interface IConfirmation extends IBaseDialogOptions {
+    /**
+     * If not provided, defaults to `Yes`.
+     */
+    readonly primaryButton?: string;
+    /**
+     * If not provided, defaults to `Cancel`.
+     */
+    readonly cancelButton?: string;
+}
+interface IConfirmationResult extends ICheckboxResult {
+    /**
+     * Will be true if the dialog was confirmed with the primary button pressed.
+     */
+    readonly confirmed: boolean;
+}
+interface IInputDialogArgs {
+    readonly input: IInput;
+}
+interface IInput extends IConfirmation {
+    readonly inputs: IInputElement[];
+    /**
+     * If not provided, defaults to `Ok`.
+     */
+    readonly primaryButton?: string;
+}
+interface IInputElement {
+    readonly type?: 'text' | 'password';
+    readonly value?: string;
+    readonly placeholder?: string;
+}
+interface IInputResult extends IConfirmationResult {
+    /**
+     * Values for the input fields as provided by the user or `undefined` if none.
+     */
+    readonly values?: string[];
+}
+interface IPromptDialogArgs {
+    readonly prompt: IPrompt<unknown>;
+}
+interface IPromptBaseButton<T> {
+    /**
+     * @returns the result of the prompt button will be returned
+     * as result from the `prompt()` call.
+     */
+    run(checkbox: ICheckboxResult): T | Promise<T>;
+}
+interface IPromptButton<T> extends IPromptBaseButton<T> {
+    readonly label: string;
+}
+interface IPromptCancelButton<T> extends IPromptBaseButton<T> {
+    /**
+     * The cancel button to show in the prompt. Defaults to
+     * `Cancel` if not provided.
+     */
+    readonly label?: string;
+}
+interface IPrompt<T> extends IBaseDialogOptions {
+    /**
+     * The buttons to show in the prompt. Defaults to `OK`
+     * if no buttons or cancel button is provided.
+     */
+    readonly buttons?: IPromptButton<T>[];
+    /**
+     * The cancel button to show in the prompt. Defaults to
+     * `Cancel` if set to `true`.
+     */
+    readonly cancelButton?: IPromptCancelButton<T> | true | string;
+}
+interface IPromptWithCustomCancel<T> extends IPrompt<T> {
+    readonly cancelButton: IPromptCancelButton<T>;
+}
+interface IPromptWithDefaultCancel<T> extends IPrompt<T> {
+    readonly cancelButton: true | string;
+}
+interface IPromptResult<T> extends ICheckboxResult {
+    /**
+     * The result of the `IPromptButton`` that was pressed or `undefined` if none.
+     */
+    readonly result?: T;
+}
+interface IPromptResultWithCancel<T> extends IPromptResult<T> {
+    readonly result: T;
+}
+type IDialogResult = IConfirmationResult | IInputResult | IPromptResult<unknown>;
+type DialogType = 'none' | 'info' | 'error' | 'question' | 'warning';
+interface ICheckbox {
+    readonly label: string;
+    readonly checked?: boolean;
+}
+interface ICheckboxResult {
+    /**
+     * This will only be defined if the confirmation was created
+     * with the checkbox option defined.
+     */
+    readonly checkboxChecked?: boolean;
+}
+interface ICustomDialogOptions {
+    readonly buttonDetails?: string[];
+    readonly markdownDetails?: ICustomDialogMarkdown[];
+    readonly classes?: string[];
+    readonly icon?: ThemeIcon;
+    readonly disableCloseAction?: boolean;
+}
+interface ICustomDialogMarkdown {
+    readonly markdown: IMarkdownString;
+    readonly classes?: string[];
+}
+/**
+ * A handler to bring up modal dialogs.
+ */
+interface IDialogHandler {
+    /**
+     * Ask the user for confirmation with a modal dialog.
+     */
+    confirm(confirmation: IConfirmation): Promise<IConfirmationResult>;
+    /**
+     * Prompt the user with a modal dialog.
+     */
+    prompt<T>(prompt: IPrompt<T>): Promise<IPromptResult<T>>;
+    /**
+     * Present a modal dialog to the user asking for input.
+     */
+    input(input: IInput): Promise<IInputResult>;
+    /**
+     * Present the about dialog to the user.
+     */
+    about(): Promise<void>;
+}
+declare const IDialogService: ServiceIdentifier<IDialogService>;
+/**
+ * A service to bring up modal dialogs.
+ *
+ * Note: use the `INotificationService.prompt()` method for a non-modal way to ask
+ * the user for input.
+ */
+interface IDialogService {
+    readonly _serviceBrand: undefined;
+    /**
+     * An event that fires when a dialog is about to show.
+     */
+    onWillShowDialog: Event<void>;
+    /**
+     * An event that fires when a dialog did show (closed).
+     */
+    onDidShowDialog: Event<void>;
+    /**
+     * Ask the user for confirmation with a modal dialog.
+     */
+    confirm(confirmation: IConfirmation): Promise<IConfirmationResult>;
+    /**
+     * Prompt the user with a modal dialog. Provides a bit
+     * more control over the dialog compared to the simpler
+     * `confirm` method. Specifically, allows to show more
+     * than 2 buttons and makes it easier to just show a
+     * message to the user.
+     *
+     * @returns a promise that resolves to the `T` result
+     * from the provided `IPromptButton<T>` or `undefined`.
+     */
+    prompt<T>(prompt: IPromptWithCustomCancel<T>): Promise<IPromptResultWithCancel<T>>;
+    prompt<T>(prompt: IPromptWithDefaultCancel<T>): Promise<IPromptResult<T>>;
+    prompt<T>(prompt: IPrompt<T>): Promise<IPromptResult<T>>;
+    /**
+     * Present a modal dialog to the user asking for input.
+     */
+    input(input: IInput): Promise<IInputResult>;
+    /**
+     * Show a modal info dialog.
+     */
+    info(message: string, detail?: string): Promise<void>;
+    /**
+     * Show a modal warning dialog.
+     */
+    warn(message: string, detail?: string): Promise<void>;
+    /**
+     * Show a modal error dialog.
+     */
+    error(message: string, detail?: string): Promise<void>;
+    /**
+     * Present the about dialog to the user.
+     */
+    about(): Promise<void>;
+}
+declare const enum ConfirmResult {
+    SAVE = 0,
+    DONT_SAVE = 1,
+    CANCEL = 2
+}
+
+interface IEditorCloseHandler {
+    /**
+     * If `true`, will call into the `confirm` method to ask for confirmation
+     * before closing the editor.
+     */
+    showConfirm(): boolean;
+    /**
+     * Allows an editor to control what should happen when the editor
+     * (or a list of editor of the same kind) is being closed.
+     *
+     * By default a file specific dialog will open if the editor is
+     * dirty and not in the process of saving.
+     *
+     * If the editor is not dealing with files or another condition
+     * should be used besides dirty state, this method should be
+     * implemented to show a different dialog.
+     *
+     * @param editors All editors of the same kind that are being closed. Should be used
+     * to show a combined dialog.
+     */
+    confirm(editors: ReadonlyArray<IEditorIdentifier>): Promise<ConfirmResult>;
+}
+/**
+ * Editor inputs are lightweight objects that can be passed to the workbench API to open inside the editor part.
+ * Each editor input is mapped to an editor that is capable of opening it through the Platform facade.
+ */
+declare abstract class EditorInput extends AbstractEditorInput {
+    protected readonly _onDidChangeDirty: Emitter<void>;
+    protected readonly _onDidChangeLabel: Emitter<void>;
+    protected readonly _onDidChangeCapabilities: Emitter<void>;
+    private readonly _onWillDispose;
+    /**
+     * Triggered when this input changes its dirty state.
+     */
+    readonly onDidChangeDirty: Event<void>;
+    /**
+     * Triggered when this input changes its label
+     */
+    readonly onDidChangeLabel: Event<void>;
+    /**
+     * Triggered when this input changes its capabilities.
+     */
+    readonly onDidChangeCapabilities: Event<void>;
+    /**
+     * Triggered when this input is about to be disposed.
+     */
+    readonly onWillDispose: Event<void>;
+    private disposed;
+    /**
+     * Optional: subclasses can override to implement
+     * custom confirmation on close behavior.
+     */
+    readonly closeHandler?: IEditorCloseHandler;
+    /**
+     * Unique type identifier for this input. Every editor input of the
+     * same class should share the same type identifier. The type identifier
+     * is used for example for serialising/deserialising editor inputs
+     * via the serialisers of the `EditorInputFactoryRegistry`.
+     */
+    abstract get typeId(): string;
+    /**
+     * Returns the optional associated resource of this input.
+     *
+     * This resource should be unique for all editors of the same
+     * kind and input and is often used to identify the editor input among
+     * others.
+     *
+     * **Note:** DO NOT use this property for anything but identity
+     * checks. DO NOT use this property to present as label to the user.
+     * Please refer to `EditorResourceAccessor` documentation in that case.
+     */
+    abstract get resource(): URI | undefined;
+    /**
+     * Identifies the type of editor this input represents
+     * This ID is registered with the {@link EditorResolverService} to allow
+     * for resolving an untyped input to a typed one
+     */
+    get editorId(): string | undefined;
+    /**
+     * The capabilities of the input.
+     */
+    get capabilities(): EditorInputCapabilities;
+    /**
+     * Figure out if the input has the provided capability.
+     */
+    hasCapability(capability: EditorInputCapabilities): boolean;
+    /**
+     * Returns the display name of this input.
+     */
+    getName(): string;
+    /**
+     * Returns the display description of this input.
+     */
+    getDescription(verbosity?: Verbosity): string | undefined;
+    /**
+     * Returns the display title of this input.
+     */
+    getTitle(verbosity?: Verbosity): string;
+    /**
+     * Returns the extra classes to apply to the label of this input.
+     */
+    getLabelExtraClasses(): string[];
+    /**
+     * Returns the aria label to be read out by a screen reader.
+     */
+    getAriaLabel(): string;
+    /**
+     * Returns a descriptor suitable for telemetry events.
+     *
+     * Subclasses should extend if they can contribute.
+     */
+    getTelemetryDescriptor(): {
+        [key: string]: unknown;
+    };
+    /**
+     * Returns if this input is dirty or not.
+     */
+    isDirty(): boolean;
+    /**
+     * Returns if this input is currently being saved or soon to be
+     * saved. Based on this assumption the editor may for example
+     * decide to not signal the dirty state to the user assuming that
+     * the save is scheduled to happen anyway.
+     */
+    isSaving(): boolean;
+    /**
+     * Returns a type of `IEditorModel` that represents the resolved input.
+     * Subclasses should override to provide a meaningful model or return
+     * `null` if the editor does not require a model.
+     *
+     * The `options` parameter are passed down from the editor when the
+     * input is resolved as part of it.
+     */
+    resolve(options?: IEditorOptions): Promise<IEditorModel | null>;
+    /**
+     * Saves the editor. The provided groupId helps implementors
+     * to e.g. preserve view state of the editor and re-open it
+     * in the correct group after saving.
+     *
+     * @returns the resulting editor input (typically the same) of
+     * this operation or `undefined` to indicate that the operation
+     * failed or was canceled.
+     */
+    save(group: GroupIdentifier, options?: ISaveOptions): Promise<EditorInput | IUntypedEditorInput | undefined>;
+    /**
+     * Saves the editor to a different location. The provided `group`
+     * helps implementors to e.g. preserve view state of the editor
+     * and re-open it in the correct group after saving.
+     *
+     * @returns the resulting editor input (typically a different one)
+     * of this operation or `undefined` to indicate that the operation
+     * failed or was canceled.
+     */
+    saveAs(group: GroupIdentifier, options?: ISaveOptions): Promise<EditorInput | IUntypedEditorInput | undefined>;
+    /**
+     * Reverts this input from the provided group.
+     */
+    revert(group: GroupIdentifier, options?: IRevertOptions): Promise<void>;
+    /**
+     * Called to determine how to handle a resource that is renamed that matches
+     * the editors resource (or is a child of).
+     *
+     * Implementors are free to not implement this method to signal no intent
+     * to participate. If an editor is returned though, it will replace the
+     * current one with that editor and optional options.
+     */
+    rename(group: GroupIdentifier, target: URI): Promise<IMoveResult | undefined>;
+    /**
+     * Returns a copy of the current editor input. Used when we can't just reuse the input
+     */
+    copy(): EditorInput;
+    /**
+     * Returns if the other object matches this input.
+     */
+    matches(otherInput: EditorInput | IUntypedEditorInput): boolean;
+    /**
+     * If a editor was registered onto multiple editor panes, this method
+     * will be asked to return the preferred one to use.
+     *
+     * @param editorPanes a list of editor pane descriptors that are candidates
+     * for the editor to open in.
+     */
+    prefersEditorPane<T extends IEditorDescriptor<IEditorPane>>(editorPanes: T[]): T | undefined;
+    /**
+     * Returns a representation of this typed editor input as untyped
+     * resource editor input that e.g. can be used to serialize the
+     * editor input into a form that it can be restored.
+     *
+     * May return `undefined` if an untyped representation is not supported.
+     *
+     * @param options additional configuration for the expected return type.
+     * When `preserveViewState` is provided, implementations should try to
+     * preserve as much view state as possible from the typed input based on
+     * the group the editor is opened.
+     */
+    toUntyped(options?: {
+        preserveViewState: GroupIdentifier;
+    }): IUntypedEditorInput | undefined;
+    /**
+     * Returns if this editor is disposed.
+     */
+    isDisposed(): boolean;
+    dispose(): 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
+}
+/**
+ * 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>;
+    isDirty(): 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 IGroupModelChangeEvent {
+    /**
+     * The kind of change that occurred in the group model.
+     */
+    readonly kind: GroupModelChangeKind;
+    /**
+     * Only applies when editors change providing
+     * access to the editor the event is about.
+     */
+    readonly editor?: EditorInput;
+    /**
+     * Only applies when editors change providing
+     * access to the index of the editor the event
+     * is about.
+     */
+    readonly editorIndex?: number;
+}
+
+declare const enum GroupDirection {
+    UP = 0,
+    DOWN = 1,
+    LEFT = 2,
+    RIGHT = 3
+}
+declare const enum GroupOrientation {
+    HORIZONTAL = 0,
+    VERTICAL = 1
+}
+declare const enum GroupLocation {
+    FIRST = 0,
+    LAST = 1,
+    NEXT = 2,
+    PREVIOUS = 3
+}
+interface IFindGroupScope {
+    direction?: GroupDirection;
+    location?: GroupLocation;
+}
+declare const enum GroupsArrangement {
+    /**
+     * Make the current active group consume the maximum
+     * amount of space possible.
+     */
+    MAXIMIZE = 0,
+    /**
+     * Size all groups evenly.
+     */
+    EVEN = 1,
+    /**
+     * Will behave like MINIMIZE_OTHERS if the active
+     * group is not already maximized and EVEN otherwise
+     */
+    TOGGLE = 2
+}
+interface GroupLayoutArgument {
+    /**
+     * Only applies when there are multiple groups
+     * arranged next to each other in a row or column.
+     * If provided, their sum must be 1 to be applied
+     * per row or column.
+     */
+    size?: number;
+    /**
+     * Editor groups  will be laid out orthogonal to the
+     * parent orientation.
+     */
+    groups?: GroupLayoutArgument[];
+}
+interface EditorGroupLayout {
+    /**
+     * The initial orientation of the editor groups at the root.
+     */
+    orientation: GroupOrientation;
+    /**
+     * The editor groups at the root of the layout.
+     */
+    groups: GroupLayoutArgument[];
+}
+interface IAddGroupOptions {
+    activate?: boolean;
+}
+declare const enum MergeGroupMode {
+    COPY_EDITORS = 0,
+    MOVE_EDITORS = 1
+}
+interface IMergeGroupOptions {
+    mode?: MergeGroupMode;
+    index?: number;
+}
+interface ICloseEditorOptions {
+    preserveFocus?: boolean;
+}
+type ICloseEditorsFilter = {
+    except?: EditorInput;
+    direction?: CloseDirection;
+    savedOnly?: boolean;
+    excludeSticky?: boolean;
+};
+interface ICloseAllEditorsOptions {
+    excludeSticky?: boolean;
+}
+interface IEditorReplacement {
+    editor: EditorInput;
+    replacement: EditorInput;
+    options?: IEditorOptions;
+    /**
+     * Skips asking the user for confirmation and doesn't
+     * save the document. Only use this if you really need to!
+     */
+    forceReplaceDirty?: boolean;
+}
+declare const enum GroupsOrder {
+    /**
+     * Groups sorted by creation order (oldest one first)
+     */
+    CREATION_TIME = 0,
+    /**
+     * Groups sorted by most recent activity (most recent active first)
+     */
+    MOST_RECENTLY_ACTIVE = 1,
+    /**
+     * Groups sorted by grid widget order
+     */
+    GRID_APPEARANCE = 2
+}
+interface IEditorSideGroup {
+    /**
+     * Open an editor in this group.
+     *
+     * @returns a promise that resolves around an IEditor instance unless
+     * the call failed, or the editor was not opened as active editor.
+     */
+    openEditor(editor: EditorInput, options?: IEditorOptions): Promise<IEditorPane | undefined>;
+}
+
+declare const IEditorGroupsService: ServiceIdentifier<IEditorGroupsService>;
+interface IEditorGroupsService {
+    readonly _serviceBrand: undefined;
+    /**
+     * An event for when the active editor group changes. The active editor
+     * group is the default location for new editors to open.
+     */
+    readonly onDidChangeActiveGroup: Event<IEditorGroup>;
+    /**
+     * An event for when a new group was added.
+     */
+    readonly onDidAddGroup: Event<IEditorGroup>;
+    /**
+     * An event for when a group was removed.
+     */
+    readonly onDidRemoveGroup: Event<IEditorGroup>;
+    /**
+     * An event for when a group was moved.
+     */
+    readonly onDidMoveGroup: Event<IEditorGroup>;
+    /**
+     * An event for when a group gets activated.
+     */
+    readonly onDidActivateGroup: Event<IEditorGroup>;
+    /**
+     * An event for when the group container is layed out.
+     */
+    readonly onDidLayout: Event<IDimension>;
+    /**
+     * An event for when the group container is scrolled.
+     */
+    readonly onDidScroll: Event<void>;
+    /**
+     * An event for when the index of a group changes.
+     */
+    readonly onDidChangeGroupIndex: Event<IEditorGroup>;
+    /**
+     * An event for when the locked state of a group changes.
+     */
+    readonly onDidChangeGroupLocked: Event<IEditorGroup>;
+    /**
+     * The size of the editor groups area.
+     */
+    readonly contentDimension: IDimension;
+    /**
+     * An active group is the default location for new editors to open.
+     */
+    readonly activeGroup: IEditorGroup;
+    /**
+     * A side group allows a subset of methods on a group that is either
+     * created to the side or picked if already there.
+     */
+    readonly sideGroup: IEditorSideGroup;
+    /**
+     * All groups that are currently visible in the editor area in the
+     * order of their creation (oldest first).
+     */
+    readonly groups: readonly IEditorGroup[];
+    /**
+     * The number of editor groups that are currently opened.
+     */
+    readonly count: number;
+    /**
+     * The current layout orientation of the root group.
+     */
+    readonly orientation: GroupOrientation;
+    /**
+     * A property that indicates when groups have been created
+     * and are ready to be used.
+     */
+    readonly isReady: boolean;
+    /**
+     * A promise that resolves when groups have been created
+     * and are ready to be used.
+     *
+     * Await this promise to safely work on the editor groups model
+     * (for example, install editor group listeners).
+     *
+     * Use the `whenRestored` property to await visible editors
+     * having fully resolved.
+     */
+    readonly whenReady: Promise<void>;
+    /**
+     * A promise that resolves when groups have been restored.
+     *
+     * For groups with active editor, the promise will resolve
+     * when the visible editor has finished to resolve.
+     *
+     * Use the `whenReady` property to not await editors to
+     * resolve.
+     */
+    readonly whenRestored: Promise<void>;
+    /**
+     * Find out if the editor group service has UI state to restore
+     * from a previous session.
+     */
+    readonly hasRestorableState: boolean;
+    /**
+     * Get all groups that are currently visible in the editor area.
+     *
+     * @param order the order of the editors to use
+     */
+    getGroups(order: GroupsOrder): readonly IEditorGroup[];
+    /**
+     * Allows to convert a group identifier to a group.
+     */
+    getGroup(identifier: GroupIdentifier): IEditorGroup | undefined;
+    /**
+     * Set a group as active. An active group is the default location for new editors to open.
+     */
+    activateGroup(group: IEditorGroup | GroupIdentifier): IEditorGroup;
+    /**
+     * Returns the size of a group.
+     */
+    getSize(group: IEditorGroup | GroupIdentifier): {
+        width: number;
+        height: number;
+    };
+    /**
+     * Sets the size of a group.
+     */
+    setSize(group: IEditorGroup | GroupIdentifier, size: {
+        width: number;
+        height: number;
+    }): void;
+    /**
+     * Arrange all groups according to the provided arrangement.
+     */
+    arrangeGroups(arrangement: GroupsArrangement): void;
+    /**
+     * Applies the provided layout by either moving existing groups or creating new groups.
+     */
+    applyLayout(layout: EditorGroupLayout): void;
+    /**
+     * Returns an editor layout describing the current grid
+     */
+    getLayout(): EditorGroupLayout;
+    /**
+     * Enable or disable centered editor layout.
+     */
+    centerLayout(active: boolean): void;
+    /**
+     * Find out if the editor layout is currently centered.
+     */
+    isLayoutCentered(): boolean;
+    /**
+     * Sets the orientation of the root group to be either vertical or horizontal.
+     */
+    setGroupOrientation(orientation: GroupOrientation): void;
+    /**
+     * Find a group in a specific scope:
+     * * `GroupLocation.FIRST`: the first group
+     * * `GroupLocation.LAST`: the last group
+     * * `GroupLocation.NEXT`: the next group from either the active one or `source`
+     * * `GroupLocation.PREVIOUS`: the previous group from either the active one or `source`
+     * * `GroupDirection.UP`: the next group above the active one or `source`
+     * * `GroupDirection.DOWN`: the next group below the active one or `source`
+     * * `GroupDirection.LEFT`: the next group to the left of the active one or `source`
+     * * `GroupDirection.RIGHT`: the next group to the right of the active one or `source`
+     *
+     * @param scope the scope of the group to search in
+     * @param source optional source to search from
+     * @param wrap optionally wrap around if reaching the edge of groups
+     */
+    findGroup(scope: IFindGroupScope, source?: IEditorGroup | GroupIdentifier, wrap?: boolean): IEditorGroup | undefined;
+    /**
+     * Add a new group to the editor area. A new group is added by splitting a provided one in
+     * one of the four directions.
+     *
+     * @param location the group from which to split to add a new group
+     * @param direction the direction of where to split to
+     * @param options configure the newly group with options
+     */
+    addGroup(location: IEditorGroup | GroupIdentifier, direction: GroupDirection, options?: IAddGroupOptions): IEditorGroup;
+    /**
+     * Remove a group from the editor area.
+     */
+    removeGroup(group: IEditorGroup | GroupIdentifier): void;
+    /**
+     * Move a group to a new group in the editor area.
+     *
+     * @param group the group to move
+     * @param location the group from which to split to add the moved group
+     * @param direction the direction of where to split to
+     */
+    moveGroup(group: IEditorGroup | GroupIdentifier, location: IEditorGroup | GroupIdentifier, direction: GroupDirection): IEditorGroup;
+    /**
+     * Merge the editors of a group into a target group. By default, all editors will
+     * move and the source group will close. This behaviour can be configured via the
+     * `IMergeGroupOptions` options.
+     *
+     * @param group the group to merge
+     * @param target the target group to merge into
+     * @param options controls how the merge should be performed. by default all editors
+     * will be moved over to the target and the source group will close. Configure to
+     * `MOVE_EDITORS_KEEP_GROUP` to prevent the source group from closing. Set to
+     * `COPY_EDITORS` to copy the editors into the target instead of moding them.
+     */
+    mergeGroup(group: IEditorGroup | GroupIdentifier, target: IEditorGroup | GroupIdentifier, options?: IMergeGroupOptions): IEditorGroup;
+    /**
+     * Merge all editor groups into the active one.
+     */
+    mergeAllGroups(): IEditorGroup;
+    /**
+     * Copy a group to a new group in the editor area.
+     *
+     * @param group the group to copy
+     * @param location the group from which to split to add the copied group
+     * @param direction the direction of where to split to
+     */
+    copyGroup(group: IEditorGroup | GroupIdentifier, location: IEditorGroup | GroupIdentifier, direction: GroupDirection): IEditorGroup;
+    /**
+     * Access the options of the editor part.
+     */
+    readonly partOptions: IEditorPartOptions;
+    /**
+     * An event that notifies when editor part options change.
+     */
+    readonly onDidChangeEditorPartOptions: Event<IEditorPartOptionsChangeEvent>;
+    /**
+     * Enforce editor part options temporarily.
+     */
+    enforcePartOptions(options: IEditorPartOptions): IDisposable;
+}
+interface IEditorGroup {
+    /**
+     * An event which fires whenever the underlying group model changes.
+     */
+    readonly onDidModelChange: Event<IGroupModelChangeEvent>;
+    /**
+     * An event that is fired when the group gets disposed.
+     */
+    readonly onWillDispose: Event<void>;
+    /**
+     * An event that is fired when the active editor in the group changed.
+     */
+    readonly onDidActiveEditorChange: Event<IActiveEditorChangeEvent>;
+    /**
+     * An event that is fired when an editor is about to close.
+     */
+    readonly onWillCloseEditor: Event<IEditorCloseEvent>;
+    /**
+     * An event that is fired when an editor is closed.
+     */
+    readonly onDidCloseEditor: Event<IEditorCloseEvent>;
+    /**
+     * An event that is fired when an editor is about to move to
+     * a different group.
+     */
+    readonly onWillMoveEditor: Event<IEditorWillMoveEvent>;
+    /**
+     * An event that is fired when an editor is about to be opened
+     * in the group.
+     */
+    readonly onWillOpenEditor: Event<IEditorWillOpenEvent>;
+    /**
+     * A unique identifier of this group that remains identical even if the
+     * group is moved to different locations.
+     */
+    readonly id: GroupIdentifier;
+    /**
+     * A number that indicates the position of this group in the visual
+     * order of groups from left to right and top to bottom. The lowest
+     * index will likely be top-left while the largest index in most
+     * cases should be bottom-right, but that depends on the grid.
+     */
+    readonly index: number;
+    /**
+     * A human readable label for the group. This label can change depending
+     * on the layout of all editor groups. Clients should listen on the
+     * `onDidGroupModelChange` event to react to that.
+     */
+    readonly label: string;
+    /**
+     * A human readable label for the group to be used by screen readers.
+     */
+    readonly ariaLabel: string;
+    /**
+     * The active editor pane is the currently visible editor pane of the group.
+     */
+    readonly activeEditorPane: IVisibleEditorPane | undefined;
+    /**
+     * The active editor is the currently visible editor of the group
+     * within the current active editor pane.
+     */
+    readonly activeEditor: EditorInput | null;
+    /**
+     * The editor in the group that is in preview mode if any. There can
+     * only ever be one editor in preview mode.
+     */
+    readonly previewEditor: EditorInput | null;
+    /**
+     * The number of opened editors in this group.
+     */
+    readonly count: number;
+    /**
+     * Whether the group has editors or not.
+     */
+    readonly isEmpty: boolean;
+    /**
+     * Whether this editor group is locked or not. Locked editor groups
+     * will only be considered for editors to open in when the group is
+     * explicitly provided for the editor.
+     *
+     * Note: editor group locking only applies when more than one group
+     * is opened.
+     */
+    readonly isLocked: boolean;
+    /**
+     * The number of sticky editors in this group.
+     */
+    readonly stickyCount: number;
+    /**
+     * All opened editors in the group in sequential order of their appearance.
+     */
+    readonly editors: readonly EditorInput[];
+    /**
+     * The scoped context key service for this group.
+     */
+    readonly scopedContextKeyService: IContextKeyService;
+    /**
+     * Get all editors that are currently opened in the group.
+     *
+     * @param order the order of the editors to use
+     * @param options options to select only specific editors as instructed
+     */
+    getEditors(order: EditorsOrder, options?: {
+        excludeSticky?: boolean;
+    }): readonly EditorInput[];
+    /**
+     * Finds all editors for the given resource that are currently
+     * opened in the group. This method will return an entry for
+     * each editor that reports a `resource` that matches the
+     * provided one.
+     *
+     * @param resource the resource of the editor to find
+     * @param options whether to support side by side editors or not
+     */
+    findEditors(resource: URI, options?: IFindEditorOptions): readonly EditorInput[];
+    /**
+     * Returns the editor at a specific index of the group.
+     */
+    getEditorByIndex(index: number): EditorInput | undefined;
+    /**
+     * Returns the index of the editor in the group or -1 if not opened.
+     */
+    getIndexOfEditor(editor: EditorInput): number;
+    /**
+     * Whether the editor is the first in the group.
+     */
+    isFirst(editor: EditorInput): boolean;
+    /**
+     * Whether the editor is the last in the group.
+     */
+    isLast(editor: EditorInput): boolean;
+    /**
+     * Open an editor in this group.
+     *
+     * @returns a promise that resolves around an IEditor instance unless
+     * the call failed, or the editor was not opened as active editor.
+     */
+    openEditor(editor: EditorInput, options?: IEditorOptions): Promise<IEditorPane | undefined>;
+    /**
+     * Opens editors in this group.
+     *
+     * @returns a promise that resolves around an IEditor instance unless
+     * the call failed, or the editor was not opened as active editor. Since
+     * a group can only ever have one active editor, even if many editors are
+     * opened, the result will only be one editor.
+     */
+    openEditors(editors: EditorInputWithOptions[]): Promise<IEditorPane | undefined>;
+    /**
+     * Find out if the provided editor is pinned in the group.
+     */
+    isPinned(editorOrIndex: EditorInput | number): boolean;
+    /**
+     * Find out if the provided editor or index of editor is sticky in the group.
+     */
+    isSticky(editorOrIndex: EditorInput | number): boolean;
+    /**
+     * Find out if the provided editor is active in the group.
+     */
+    isActive(editor: EditorInput | IUntypedEditorInput): boolean;
+    /**
+     * Find out if a certain editor is included in the group.
+     *
+     * @param candidate the editor to find
+     * @param options fine tune how to match editors
+     */
+    contains(candidate: EditorInput | IUntypedEditorInput, options?: IMatchEditorOptions): boolean;
+    /**
+     * Move an editor from this group either within this group or to another group.
+     */
+    moveEditor(editor: EditorInput, target: IEditorGroup, options?: IEditorOptions): void;
+    /**
+     * Move editors from this group either within this group or to another group.
+     */
+    moveEditors(editors: EditorInputWithOptions[], target: IEditorGroup): void;
+    /**
+     * Copy an editor from this group to another group.
+     *
+     * Note: It is currently not supported to show the same editor more than once in the same group.
+     */
+    copyEditor(editor: EditorInput, target: IEditorGroup, options?: IEditorOptions): void;
+    /**
+     * Copy editors from this group to another group.
+     *
+     * Note: It is currently not supported to show the same editor more than once in the same group.
+     */
+    copyEditors(editors: EditorInputWithOptions[], target: IEditorGroup): void;
+    /**
+     * Close an editor from the group. This may trigger a confirmation dialog if
+     * the editor is dirty and thus returns a promise as value.
+     *
+     * @param editor the editor to close, or the currently active editor
+     * if unspecified.
+     *
+     * @returns a promise when the editor is closed or not. If `true`, the editor
+     * is closed and if `false` there was a veto closing the editor, e.g. when it
+     * is dirty.
+     */
+    closeEditor(editor?: EditorInput, options?: ICloseEditorOptions): Promise<boolean>;
+    /**
+     * Closes specific editors in this group. This may trigger a confirmation dialog if
+     * there are dirty editors and thus returns a promise as value.
+     *
+     * @returns a promise whether the editors were closed or not. If `true`, the editors
+     * were closed and if `false` there was a veto closing the editors, e.g. when one
+     * is dirty.
+     */
+    closeEditors(editors: EditorInput[] | ICloseEditorsFilter, options?: ICloseEditorOptions): Promise<boolean>;
+    /**
+     * Closes all editors from the group. This may trigger a confirmation dialog if
+     * there are dirty editors and thus returns a promise as value.
+     *
+     * @returns a promise when all editors are closed.
+     */
+    closeAllEditors(options?: ICloseAllEditorsOptions): Promise<boolean>;
+    /**
+     * Replaces editors in this group with the provided replacement.
+     *
+     * @param editors the editors to replace
+     *
+     * @returns a promise that is resolved when the replaced active
+     * editor (if any) has finished loading.
+     */
+    replaceEditors(editors: IEditorReplacement[]): Promise<void>;
+    /**
+     * Set an editor to be pinned. A pinned editor is not replaced
+     * when another editor opens at the same location.
+     *
+     * @param editor the editor to pin, or the currently active editor
+     * if unspecified.
+     */
+    pinEditor(editor?: EditorInput): void;
+    /**
+     * Set an editor to be sticky. A sticky editor is showing in the beginning
+     * of the tab stripe and will not be impacted by close operations.
+     *
+     * @param editor the editor to make sticky, or the currently active editor
+     * if unspecified.
+     */
+    stickEditor(editor?: EditorInput): void;
+    /**
+     * Set an editor to be non-sticky and thus moves back to a location after
+     * sticky editors and can be closed normally.
+     *
+     * @param editor the editor to make unsticky, or the currently active editor
+     * if unspecified.
+     */
+    unstickEditor(editor?: EditorInput): void;
+    /**
+     * Whether this editor group should be locked or not.
+     *
+     * See {@linkcode IEditorGroup.isLocked `isLocked`}
+     */
+    lock(locked: boolean): void;
+    /**
+     * Move keyboard focus into the group.
+     */
+    focus(): 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>;
+}
+
+/**
+ * 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 dirty.
+     */
+    markDirty(): 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 ICopyOperation extends IMoveOperation {
+}
+/**
+ * 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 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.
+ */
+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 ILanguageSupport {
+    /**
+     * Sets the language id of the object.
+     */
+    setLanguageId(languageId: string, source?: string): void;
+}
+interface ITextFileEditorModelSaveEvent extends IWorkingCopySaveEvent {
+    /**
+     * The resolved stat from the save operation.
+     */
+    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;
+}
+
+interface IEditorDescriptor<T extends IEditorPane> {
+    /**
+     * The unique type identifier of the editor. All instances
+     * of the same `IEditorPane` should have the same type
+     * identifier.
+     */
+    readonly typeId: string;
+    /**
+     * The display name of the editor.
+     */
+    readonly name: string;
+    /**
+     * Instantiates the editor pane using the provided services.
+     */
+    instantiate(instantiationService: IInstantiationService): T;
+    /**
+     * Whether the descriptor is for the provided editor pane.
+     */
+    describes(editorPane: T): boolean;
+}
+/**
+ * The editor pane is the container for workbench editors.
+ */
+interface IEditorPane extends IComposite {
+    /**
+     * An event to notify when the `IEditorControl` in this
+     * editor pane changes.
+     *
+     * This can be used for editor panes that are a compound
+     * of multiple editor controls to signal that the active
+     * editor control has changed when the user clicks around.
+     */
+    readonly onDidChangeControl: Event<void>;
+    /**
+     * An optional event to notify when the selection inside the editor
+     * pane changed in case the editor has a selection concept.
+     *
+     * For example, in a text editor pane, the selection changes whenever
+     * the cursor is set to a new location.
+     */
+    readonly onDidChangeSelection?: Event<IEditorPaneSelectionChangeEvent>;
+    /**
+     * The assigned input of this editor.
+     */
+    readonly input: EditorInput | undefined;
+    /**
+     * The assigned options of the editor.
+     */
+    readonly options: IEditorOptions | undefined;
+    /**
+     * The assigned group this editor is showing in.
+     */
+    readonly group: IEditorGroup | undefined;
+    /**
+     * The minimum width of this editor.
+     */
+    readonly minimumWidth: number;
+    /**
+     * The maximum width of this editor.
+     */
+    readonly maximumWidth: number;
+    /**
+     * The minimum height of this editor.
+     */
+    readonly minimumHeight: number;
+    /**
+     * The maximum height of this editor.
+     */
+    readonly maximumHeight: number;
+    /**
+     * An event to notify whenever minimum/maximum width/height changes.
+     */
+    readonly onDidChangeSizeConstraints: Event<{
+        width: number;
+        height: number;
+    } | undefined>;
+    /**
+     * The context key service for this editor. Should be overridden by
+     * editors that have their own ScopedContextKeyService
+     */
+    readonly scopedContextKeyService: IContextKeyService | undefined;
+    /**
+     * Returns the underlying control of this editor. Callers need to cast
+     * the control to a specific instance as needed, e.g. by using the
+     * `isCodeEditor` helper method to access the text code editor.
+     *
+     * Use the `onDidChangeControl` event to track whenever the control
+     * changes.
+     */
+    getControl(): IEditorControl | undefined;
+    /**
+     * Returns the current view state of the editor if any.
+     *
+     * This method is optional to override for the editor pane
+     * and should only be overridden when the pane can deal with
+     * `IEditorOptions.viewState` to be applied when opening.
+     */
+    getViewState(): object | undefined;
+    /**
+     * An optional method to return the current selection in
+     * the editor pane in case the editor pane has a selection
+     * concept.
+     *
+     * Clients of this method will typically react to the
+     * `onDidChangeSelection` event to receive the current
+     * selection as needed.
+     */
+    getSelection?(): IEditorPaneSelection | undefined;
+    /**
+     * Finds out if this editor is visible or not.
+     */
+    isVisible(): boolean;
+}
+interface IEditorPaneSelectionChangeEvent {
+    /**
+     * More details for how the selection was made.
+     */
+    reason: EditorPaneSelectionChangeReason;
+}
+declare const enum EditorPaneSelectionChangeReason {
+    /**
+     * The selection was changed as a result of a programmatic
+     * method invocation.
+     *
+     * For a text editor pane, this for example can be a selection
+     * being restored from previous view state automatically.
+     */
+    PROGRAMMATIC = 1,
+    /**
+     * The selection was changed by the user.
+     *
+     * This typically means the user changed the selection
+     * with mouse or keyboard.
+     */
+    USER = 2,
+    /**
+     * The selection was changed as a result of editing in
+     * the editor pane.
+     *
+     * For a text editor pane, this for example can be typing
+     * in the text of the editor pane.
+     */
+    EDIT = 3,
+    /**
+     * The selection was changed as a result of a navigation
+     * action.
+     *
+     * For a text editor pane, this for example can be a result
+     * of selecting an entry from a text outline view.
+     */
+    NAVIGATION = 4,
+    /**
+     * The selection was changed as a result of a jump action
+     * from within the editor pane.
+     *
+     * For a text editor pane, this for example can be a result
+     * of invoking "Go to definition" from a symbol.
+     */
+    JUMP = 5
+}
+interface IEditorPaneSelection {
+    /**
+     * Asks to compare this selection to another selection.
+     */
+    compare(otherSelection: IEditorPaneSelection): EditorPaneSelectionCompareResult;
+    /**
+     * Asks to massage the provided `options` in a way
+     * that the selection can be restored when the editor
+     * is opened again.
+     *
+     * For a text editor this means to apply the selected
+     * line and column as text editor options.
+     */
+    restore(options: IEditorOptions): IEditorOptions;
+    /**
+     * Only used for logging to print more info about the selection.
+     */
+    log?(): string;
+}
+declare const enum EditorPaneSelectionCompareResult {
+    /**
+     * The selections are identical.
+     */
+    IDENTICAL = 1,
+    /**
+     * The selections are similar.
+     *
+     * For a text editor this can mean that the one
+     * selection is in close proximity to the other
+     * selection.
+     *
+     * Upstream clients may decide in this case to
+     * not treat the selection different from the
+     * previous one because it is not distinct enough.
+     */
+    SIMILAR = 2,
+    /**
+     * The selections are entirely different.
+     */
+    DIFFERENT = 3
+}
+/**
+ * Overrides `IEditorPane` where `input` and `group` are known to be set.
+ */
+interface IVisibleEditorPane extends IEditorPane {
+    readonly input: EditorInput;
+    readonly group: IEditorGroup;
+}
+/**
+ * The text editor pane is the container for workbench text diff editors.
+ */
+interface ITextDiffEditorPane extends IEditorPane {
+    /**
+     * Returns the underlying text diff editor widget of this editor.
+     */
+    getControl(): IDiffEditor | undefined;
+}
+/**
+ * Marker interface for the control inside an editor pane. Callers
+ * have to cast the control to work with it, e.g. via methods
+ * such as `isCodeEditor(control)`.
+ */
+interface IEditorControl extends ICompositeControl {
+}
+interface IUntitledTextResourceEditorInput extends IBaseTextResourceEditorInput {
+    /**
+     * Optional resource for the untitled editor. Depending on the value, the editor:
+     * - should get a unique name if `undefined` (for example `Untitled-1`)
+     * - should use the resource directly if the scheme is `untitled:`
+     * - should change the scheme to `untitled:` otherwise and assume an associated path
+     *
+     * Untitled editors with associated path behave slightly different from other untitled
+     * editors:
+     * - they are dirty right when opening
+     * - they will not ask for a file path when saving but use the associated path
+     */
+    readonly resource: URI | undefined;
+}
+/**
+ * A resource side by side editor input shows 2 editors side by side but
+ * without highlighting any differences.
+ *
+ * Note: both sides will be resolved as editor individually. As such, it is
+ * possible to show 2 different editors side by side.
+ *
+ * @see {@link IResourceDiffEditorInput} for a variant that compares 2 editors.
+ */
+interface IResourceSideBySideEditorInput extends IBaseUntypedEditorInput {
+    /**
+     * The right hand side editor to open inside a side-by-side editor.
+     */
+    readonly primary: IResourceEditorInput | ITextResourceEditorInput | IUntitledTextResourceEditorInput;
+    /**
+     * The left hand side editor to open inside a side-by-side editor.
+     */
+    readonly secondary: IResourceEditorInput | ITextResourceEditorInput | IUntitledTextResourceEditorInput;
+}
+/**
+ * A resource diff editor input compares 2 editors side by side
+ * highlighting the differences.
+ *
+ * Note: both sides must be resolvable to the same editor, or
+ * a text based presentation will be used as fallback.
+ */
+interface IResourceDiffEditorInput extends IBaseUntypedEditorInput {
+    /**
+     * The left hand side editor to open inside a diff editor.
+     */
+    readonly original: IResourceEditorInput | ITextResourceEditorInput | IUntitledTextResourceEditorInput;
+    /**
+     * The right hand side editor to open inside a diff editor.
+     */
+    readonly modified: IResourceEditorInput | ITextResourceEditorInput | IUntitledTextResourceEditorInput;
+}
+type IResourceMergeEditorInputSide = (IResourceEditorInput | ITextResourceEditorInput) & {
+    detail?: string;
+};
+/**
+ * A resource merge editor input compares multiple editors
+ * highlighting the differences for merging.
+ *
+ * Note: all sides must be resolvable to the same editor, or
+ * a text based presentation will be used as fallback.
+ */
+interface IResourceMergeEditorInput extends IBaseUntypedEditorInput {
+    /**
+     * The one changed version of the file.
+     */
+    readonly input1: IResourceMergeEditorInputSide;
+    /**
+     * The second changed version of the file.
+     */
+    readonly input2: IResourceMergeEditorInputSide;
+    /**
+     * The base common ancestor of the file to merge.
+     */
+    readonly base: IResourceEditorInput | ITextResourceEditorInput;
+    /**
+     * The resulting output of the merge.
+     */
+    readonly result: IResourceEditorInput | ITextResourceEditorInput;
+}
+declare const enum Verbosity {
+    SHORT = 0,
+    MEDIUM = 1,
+    LONG = 2
+}
+declare const enum SaveReason {
+    /**
+     * Explicit user gesture.
+     */
+    EXPLICIT = 1,
+    /**
+     * Auto save after a timeout.
+     */
+    AUTO = 2,
+    /**
+     * Auto save after editor focus change.
+     */
+    FOCUS_CHANGE = 3,
+    /**
+     * Auto save after window change.
+     */
+    WINDOW_CHANGE = 4
+}
+type SaveSource = string;
+interface ISaveOptions {
+    /**
+     * An indicator how the save operation was triggered.
+     */
+    reason?: SaveReason;
+    /**
+     * An indicator about the source of the save operation.
+     *
+     * Must use `SaveSourceRegistry.registerSource()` to obtain.
+     */
+    readonly source?: SaveSource;
+    /**
+     * Forces to save the contents of the working copy
+     * again even if the working copy is not dirty.
+     */
+    readonly force?: boolean;
+    /**
+     * Instructs the save operation to skip any save participants.
+     */
+    readonly skipSaveParticipants?: boolean;
+    /**
+     * A hint as to which file systems should be available for saving.
+     */
+    readonly availableFileSystems?: string[];
+}
+interface IRevertOptions {
+    /**
+     * Forces to load the contents of the working copy
+     * again even if the working copy is not dirty.
+     */
+    readonly force?: boolean;
+    /**
+     * A soft revert will clear dirty state of a working copy
+     * but will not attempt to load it from its persisted state.
+     *
+     * This option may be used in scenarios where an editor is
+     * closed and where we do not require to load the contents.
+     */
+    readonly soft?: boolean;
+}
+interface IMoveResult {
+    editor: EditorInput | IUntypedEditorInput;
+    options?: IEditorOptions;
+}
+declare const enum EditorInputCapabilities {
+    /**
+     * Signals no specific capability for the input.
+     */
+    None = 0,
+    /**
+     * Signals that the input is readonly.
+     */
+    Readonly = 2,
+    /**
+     * Signals that the input is untitled.
+     */
+    Untitled = 4,
+    /**
+     * Signals that the input can only be shown in one group
+     * and not be split into multiple groups.
+     */
+    Singleton = 8,
+    /**
+     * Signals that the input requires workspace trust.
+     */
+    RequiresTrust = 16,
+    /**
+     * Signals that the editor can split into 2 in the same
+     * editor group.
+     */
+    CanSplitInGroup = 32,
+    /**
+     * Signals that the editor wants its description to be
+     * visible when presented to the user. By default, a UI
+     * component may decide to hide the description portion
+     * for brevity.
+     */
+    ForceDescription = 64,
+    /**
+     * Signals that the editor supports dropping into the
+     * editor by holding shift.
+     */
+    CanDropIntoEditor = 128,
+    /**
+     * Signals that the editor is composed of multiple editors
+     * within.
+     */
+    MultipleEditors = 256
+}
+type IUntypedEditorInput = IResourceEditorInput | ITextResourceEditorInput | IUntitledTextResourceEditorInput | IResourceDiffEditorInput | IResourceSideBySideEditorInput | IResourceMergeEditorInput;
+declare abstract class AbstractEditorInput extends Disposable {
+}
+interface EditorInputWithOptions {
+    editor: EditorInput;
+    options?: IEditorOptions;
+}
+interface IEditorIdentifier {
+    groupId: GroupIdentifier;
+    editor: EditorInput;
+}
+/**
+ * More information around why an editor was closed in the model.
+ */
+declare enum EditorCloseContext {
+    /**
+     * No specific context for closing (e.g. explicit user gesture).
+     */
+    UNKNOWN = 0,
+    /**
+     * The editor closed because it was replaced with another editor.
+     * This can either happen via explicit replace call or when an
+     * editor is in preview mode and another editor opens.
+     */
+    REPLACE = 1,
+    /**
+     * The editor closed as a result of moving it to another group.
+     */
+    MOVE = 2,
+    /**
+     * The editor closed because another editor turned into preview
+     * and this used to be the preview editor before.
+     */
+    UNPIN = 3
+}
+interface IEditorCloseEvent extends IEditorIdentifier {
+    /**
+     * More information around why the editor was closed.
+     */
+    readonly context: EditorCloseContext;
+    /**
+     * The index of the editor before closing.
+     */
+    readonly index: number;
+    /**
+     * Whether the editor was sticky or not.
+     */
+    readonly sticky: boolean;
+}
+interface IActiveEditorChangeEvent {
+    /**
+     * The new active editor or `undefined` if the group is empty.
+     */
+    editor: EditorInput | undefined;
+}
+interface IEditorWillMoveEvent extends IEditorIdentifier {
+    /**
+     * The target group of the move operation.
+     */
+    readonly target: GroupIdentifier;
+}
+interface IEditorWillOpenEvent extends IEditorIdentifier {
+}
+type GroupIdentifier = number;
+declare const enum GroupModelChangeKind {
+    GROUP_ACTIVE = 0,
+    GROUP_INDEX = 1,
+    GROUP_LOCKED = 2,
+    EDITOR_OPEN = 3,
+    EDITOR_CLOSE = 4,
+    EDITOR_MOVE = 5,
+    EDITOR_ACTIVE = 6,
+    EDITOR_LABEL = 7,
+    EDITOR_CAPABILITIES = 8,
+    EDITOR_PIN = 9,
+    EDITOR_STICKY = 10,
+    EDITOR_DIRTY = 11,
+    EDITOR_WILL_DISPOSE = 12
+}
+interface IEditorPartConfiguration {
+    showTabs?: boolean;
+    wrapTabs?: boolean;
+    scrollToSwitchTabs?: boolean;
+    highlightModifiedTabs?: boolean;
+    tabCloseButton?: 'left' | 'right' | 'off';
+    tabSizing?: 'fit' | 'shrink';
+    pinnedTabSizing?: 'normal' | 'compact' | 'shrink';
+    titleScrollbarSizing?: 'default' | 'large';
+    focusRecentEditorAfterClose?: boolean;
+    showIcons?: boolean;
+    enablePreview?: boolean;
+    enablePreviewFromQuickOpen?: boolean;
+    enablePreviewFromCodeNavigation?: boolean;
+    closeOnFileDelete?: boolean;
+    openPositioning?: 'left' | 'right' | 'first' | 'last';
+    openSideBySideDirection?: 'right' | 'down';
+    closeEmptyGroups?: boolean;
+    autoLockGroups?: Set<string>;
+    revealIfOpen?: boolean;
+    mouseBackForwardToNavigate?: boolean;
+    labelFormat?: 'default' | 'short' | 'medium' | 'long';
+    restoreViewState?: boolean;
+    splitInGroupLayout?: 'vertical' | 'horizontal';
+    splitSizing?: 'split' | 'distribute';
+    splitOnDragAndDrop?: boolean;
+    centeredLayoutFixedWidth?: boolean;
+    limit?: {
+        enabled?: boolean;
+        excludeDirty?: boolean;
+        value?: number;
+        perEditorGroup?: boolean;
+    };
+    decorations?: {
+        badges?: boolean;
+        colors?: boolean;
+    };
+}
+interface IEditorPartOptions extends IEditorPartConfiguration {
+    hasIcons?: boolean;
+}
+interface IEditorPartOptionsChangeEvent {
+    oldPartOptions: IEditorPartOptions;
+    newPartOptions: IEditorPartOptions;
+}
+declare enum SideBySideEditor {
+    PRIMARY = 1,
+    SECONDARY = 2,
+    BOTH = 3,
+    ANY = 4
+}
+interface IFindEditorOptions {
+    /**
+     * Whether to consider any or both side by side editor as matching.
+     * By default, side by side editors will not be considered
+     * as matching, even if the editor is opened in one of the sides.
+     */
+    supportSideBySide?: SideBySideEditor.PRIMARY | SideBySideEditor.SECONDARY | SideBySideEditor.ANY;
+}
+interface IMatchEditorOptions {
+    /**
+     * Whether to consider a side by side editor as matching.
+     * By default, side by side editors will not be considered
+     * as matching, even if the editor is opened in one of the sides.
+     */
+    supportSideBySide?: SideBySideEditor.ANY | SideBySideEditor.BOTH;
+    /**
+     * Only consider an editor to match when the
+     * `candidate === editor` but not when
+     * `candidate.matches(editor)`.
+     */
+    strictEquals?: boolean;
+}
+declare const enum CloseDirection {
+    LEFT = 0,
+    RIGHT = 1
+}
+declare const enum EditorsOrder {
+    /**
+     * Editors sorted by most recent activity (most recent active first)
+     */
+    MOST_RECENTLY_ACTIVE = 0,
+    /**
+     * Editors sorted by sequential order
+     */
+    SEQUENTIAL = 1
+}
+
+interface LanguageFilter {
+    readonly language?: string;
+    readonly scheme?: string;
+    readonly pattern?: string | IRelativePattern;
+    readonly notebookType?: string;
+    /**
+     * This provider is implemented in the UI thread.
+     */
+    readonly hasAccessToAllModels?: boolean;
+    readonly exclusive?: boolean;
+    /**
+     * This provider comes from a builtin extension.
+     */
+    readonly isBuiltin?: boolean;
+}
+type LanguageSelector = string | LanguageFilter | ReadonlyArray<string | LanguageFilter>;
+
+interface NotebookInfo {
+    readonly uri: URI;
+    readonly type: string;
+}
+interface NotebookInfoResolver {
+    (uri: URI): NotebookInfo | undefined;
+}
+declare class LanguageFeatureRegistry<T> {
+    private readonly _notebookInfoResolver?;
+    private _clock;
+    private readonly _entries;
+    private readonly _onDidChange;
+    readonly onDidChange: Event<number>;
+    constructor(_notebookInfoResolver?: NotebookInfoResolver | undefined);
+    register(selector: LanguageSelector, provider: T): IDisposable;
+    has(model: ITextModel): boolean;
+    all(model: ITextModel): T[];
+    ordered(model: ITextModel): T[];
+    orderedGroups(model: ITextModel): T[][];
+    private _orderedForEach;
+    private _lastCandidate;
+    private _updateScores;
+    private static _compareByScoreAndTime;
+}
+
+declare const ILanguageFeaturesService: ServiceIdentifier<ILanguageFeaturesService>;
+interface ILanguageFeaturesService {
+    readonly _serviceBrand: undefined;
+    readonly referenceProvider: LanguageFeatureRegistry<ReferenceProvider>;
+    readonly definitionProvider: LanguageFeatureRegistry<DefinitionProvider>;
+    readonly typeDefinitionProvider: LanguageFeatureRegistry<TypeDefinitionProvider>;
+    readonly declarationProvider: LanguageFeatureRegistry<DeclarationProvider>;
+    readonly implementationProvider: LanguageFeatureRegistry<ImplementationProvider>;
+    readonly codeActionProvider: LanguageFeatureRegistry<CodeActionProvider>;
+    readonly documentPasteEditProvider: LanguageFeatureRegistry<DocumentPasteEditProvider>;
+    readonly renameProvider: LanguageFeatureRegistry<RenameProvider>;
+    readonly documentFormattingEditProvider: LanguageFeatureRegistry<DocumentFormattingEditProvider>;
+    readonly documentRangeFormattingEditProvider: LanguageFeatureRegistry<DocumentRangeFormattingEditProvider>;
+    readonly onTypeFormattingEditProvider: LanguageFeatureRegistry<OnTypeFormattingEditProvider>;
+    readonly documentSymbolProvider: LanguageFeatureRegistry<DocumentSymbolProvider>;
+    readonly inlayHintsProvider: LanguageFeatureRegistry<InlayHintsProvider>;
+    readonly colorProvider: LanguageFeatureRegistry<DocumentColorProvider>;
+    readonly codeLensProvider: LanguageFeatureRegistry<CodeLensProvider>;
+    readonly signatureHelpProvider: LanguageFeatureRegistry<SignatureHelpProvider>;
+    readonly hoverProvider: LanguageFeatureRegistry<HoverProvider>;
+    readonly documentHighlightProvider: LanguageFeatureRegistry<DocumentHighlightProvider>;
+    readonly documentRangeSemanticTokensProvider: LanguageFeatureRegistry<DocumentRangeSemanticTokensProvider>;
+    readonly documentSemanticTokensProvider: LanguageFeatureRegistry<DocumentSemanticTokensProvider>;
+    readonly selectionRangeProvider: LanguageFeatureRegistry<SelectionRangeProvider>;
+    readonly foldingRangeProvider: LanguageFeatureRegistry<FoldingRangeProvider>;
+    readonly linkProvider: LanguageFeatureRegistry<LinkProvider>;
+    readonly inlineCompletionsProvider: LanguageFeatureRegistry<InlineCompletionsProvider>;
+    readonly completionProvider: LanguageFeatureRegistry<CompletionItemProvider>;
+    readonly linkedEditingRangeProvider: LanguageFeatureRegistry<LinkedEditingRangeProvider>;
+    readonly inlineValuesProvider: LanguageFeatureRegistry<InlineValuesProvider>;
+    readonly evaluatableExpressionProvider: LanguageFeatureRegistry<EvaluatableExpressionProvider>;
+    readonly documentOnDropEditProvider: LanguageFeatureRegistry<DocumentOnDropEditProvider>;
+    setNotebookTypeResolver(resolver: NotebookInfoResolver | undefined): void;
+}
+
+export { IPromptResultWithCancel as $, IDialogHandler as A, IConfirmDialogArgs as B, Command as C, DialogType as D, EditorInput as E, IInputDialogArgs as F, GroupIdentifier as G, IPromptDialogArgs as H, ILanguageIdCodec as I, IBaseDialogOptions as J, ICheckbox as K, LanguageSelector as L, ICheckboxResult as M, ICustomDialogOptions as N, ICustomDialogMarkdown as O, IConfirmation as P, IConfirmationResult as Q, IInput as R, IInputResult as S, TextEdit as T, IInputElement as U, IPrompt as V, WorkspaceEdit as W, IPromptResult as X, IPromptBaseButton as Y, IPromptButton as Z, IPromptCancelButton as _, IEditorCloseEvent as a, IPromptWithCustomCancel as a0, IPromptWithDefaultCancel as a1, LanguageFeatureRegistry as a2, FoldingRangeProvider as a3, ITextFileEditorModel as a4, IVisibleEditorPane as b, EditorsOrder as c, IEditorIdentifier as d, IEditorGroup as e, IEditorPane as f, IUntitledTextResourceEditorInput as g, IResourceDiffEditorInput as h, ITextDiffEditorPane as i, IUntypedEditorInput as j, ICloseEditorOptions as k, IFindEditorOptions as l, IRevertOptions as m, ISaveOptions as n, IGroupModelChangeEvent as o, IInplaceReplaceSupportResult as p, WorkspaceEditMetadata as q, ILanguageConfigurationService as r, ILanguageFeaturesService as s, IDialogService as t, IMarkerService as u, IEditorGroupsService as v, ITextFileService as w, IWorkingCopyFileService as x, IDialogArgs as y, IDialogResult as z };