@codingame/monaco-vscode-api 1.79.0 → 1.79.2-next.0

package/dist/services.d.ts

@@ -1,34 +1,31 @@
 /// <reference path="./debugProtocol.d.ts" />
 
-import { E as Event, I as IDisposable, C as CancellationToken } from './event.js';
-import { I as IMarkdownString, a as IResourceEditorInput, b as ITextResourceEditorInput, c as IEditorOptions, d as IResourceEditorInputIdentifier } from './editor.js';
-export { M as MarkdownStringTrustedOptions } from './editor.js';
-import { S as ServiceIdentifier, a as ServicesAccessor } from './instantiation.js';
-export { I as IInstantiationService } from './instantiation.js';
-import { I as IProgress, a as IProgressStep, b as IProgressIndicator } from './colorRegistry.js';
-export { c as IAction, d as ICommandService, j as INeverShowAgainOptions, k as INotification, l as INotificationActions, o as INotificationHandle, m as INotificationProgress, n as INotificationProgressProperties, h as INotificationProperties, e as INotificationService, p as IPromptChoice, q as IPromptChoiceWithMenu, r as IPromptOptions, s as IStatusMessageOptions, i as NeverShowAgainScope, t as NoOpNotification, u as NoOpProgress, f as NotificationMessage, g as NotificationPriority, N as NotificationsFilter } from './colorRegistry.js';
-import { S as Severity, E as ExtensionIdentifier, I as IExtensionDescription } from './extensions.d2.ts';
-import { V as VSBuffer, I as IFileService } from './files.js';
-import { I as ILanguageIdCodec, a as IEditorCloseEvent, b as IVisibleEditorPane, E as EditorInput, c as EditorsOrder, d as IEditorIdentifier, e as IEditorGroup, G as GroupIdentifier, f as IEditorPane, g as IUntitledTextResourceEditorInput, h as IResourceDiffEditorInput, i as ITextDiffEditorPane, j as IUntypedEditorInput, k as ICloseEditorOptions, l as IFindEditorOptions, m as IRevertOptions, n as ISaveOptions, o as IGroupModelChangeEvent, L as LanguageSelector, C as Command, T as TextEdit, p as IInplaceReplaceSupportResult, W as WorkspaceEdit, q as WorkspaceEditMetadata } from './languageFeatures.js';
-export { D as DialogType, J as IBaseDialogOptions, K as ICheckbox, M as ICheckboxResult, B as IConfirmDialogArgs, P as IConfirmation, Q as IConfirmationResult, O as ICustomDialogMarkdown, N as ICustomDialogOptions, y as IDialogArgs, A as IDialogHandler, z as IDialogResult, t as IDialogService, v as IEditorGroupsService, R as IInput, F as IInputDialogArgs, U as IInputElement, S as IInputResult, r as ILanguageConfigurationService, s as ILanguageFeaturesService, u as IMarkerService, V as IPrompt, Y as IPromptBaseButton, Z as IPromptButton, _ as IPromptCancelButton, H as IPromptDialogArgs, X as IPromptResult, $ as IPromptResultWithCancel, a0 as IPromptWithCustomCancel, a1 as IPromptWithDefaultCancel, w as ITextFileService, x as IWorkingCopyFileService } from './languageFeatures.js';
-import { U as URI } from './uri.js';
-import { C as ConfigurationTarget, I as ITelemetryEndpoint, a as IOpenEmptyWindowOptions, b as IWindowOpenable, c as IOpenWindowOptions, d as IPaneComposite, V as ViewContainerLocation, P as PaneCompositeDescriptor, e as IBadge } from './activity.js';
-export { g as IColorTheme, f as IConfigurationChangeEvent, l as IConfigurationService, p as ILayoutService, i as IOpenerService, n as IStorageService, j as ITelemetryService, m as IThemeService, o as IViewsService, k as IWorkbenchEnvironmentService, S as StorageScope, h as StorageTarget } from './activity.js';
-import { I as IStringDictionary } from './collections.js';
+import { E as Event$1, a as IDisposable, C as CancellationToken, D as Disposable, c as Emitter } from './event.js';
+import { i as IMarkdownString, l as IEditorModel, p as ITextBufferFactory, c as ITextModel, v as ITextModelCreationOptions, w as IEditor, q as IDiffEditor, t as IResourceEditorInput, u as ITextResourceEditorInput, I as IEditorOptions, x as IResourceEditorInputIdentifier, h as IRange, g as IPosition, P as Position$1, y as IDocumentDiffProviderOptions, z as IDocumentDiff, A as IChange, b as ICodeEditor, B as IBoundarySashes, O as Orientation, C as IDiffEditor$1, D as IDecorationRenderOptions, d as IModelDecorationOptions } from './editorBrowser.js';
+export { F as ITextModelContentProvider, G as ITextModelService, M as MarkdownStringTrustedOptions } from './editorBrowser.js';
+import { S as ServiceIdentifier, c as IConstructorSignature, I as IInstantiationService, B as BrandedService, a as ServicesAccessor } from './instantiation.js';
+import { d as ILanguageIdCodec, S as SubmenuAction, e as IAction, f as ICommandService, g as IEditorCloseEvent, h as IVisibleEditorPane, E as EditorInput, i as EditorsOrder, j as IEditorIdentifier, k as IEditorGroup, G as GroupIdentifier, l as IEditorPane, m as IUntitledTextResourceEditorInput, n as IResourceDiffEditorInput, o as ITextDiffEditorPane, p as IUntypedEditorInput, q as ICloseEditorOptions, s as IFindEditorOptions, t as IRevertOptions, u as ISaveOptions, v as IGroupModelChangeEvent, w as ColorIdentifier, x as Color, y as LanguageSelector, z as Command, T as TextEdit, A as IInplaceReplaceSupportResult, W as WorkspaceEdit, B as WorkspaceEditMetadata, D as IActionRunner } from './languageFeatures.js';
+export { a7 as DialogType, ad as IBaseDialogOptions, ae as ICheckbox, af as ICheckboxResult, aa as IConfirmDialogArgs, ai as IConfirmation, aj as IConfirmationResult, ah as ICustomDialogMarkdown, ag as ICustomDialogOptions, a6 as IDialogArgs, a9 as IDialogHandler, a8 as IDialogResult, H as IDialogService, K as IEditorGroupsService, ak as IInput, ab as IInputDialogArgs, am as IInputElement, al as IInputResult, a as ILanguageConfigurationService, I as ILanguageFeaturesService, J as IMarkerService, V as INeverShowAgainOptions, X as INotification, Y as INotificationActions, $ as INotificationHandle, Z as INotificationProgress, _ as INotificationProgressProperties, R as INotificationProperties, b as INotificationService, an as IPrompt, ap as IPromptBaseButton, aq as IPromptButton, ar as IPromptCancelButton, a0 as IPromptChoice, a1 as IPromptChoiceWithMenu, ac as IPromptDialogArgs, a2 as IPromptOptions, ao as IPromptResult, as as IPromptResultWithCancel, at as IPromptWithCustomCancel, au as IPromptWithDefaultCancel, a3 as IStatusMessageOptions, M as ITextFileService, N as IWorkingCopyFileService, U as NeverShowAgainScope, a4 as NoOpNotification, a5 as NoOpProgress, P as NotificationMessage, Q as NotificationPriority, O as NotificationsFilter } from './languageFeatures.js';
+import { S as Severity } from './severity.js';
+import { c as FileType, V as VSBuffer, w as IFileService } from './files.js';
+import { a as UriComponents, U as URI } from './uri.js';
+import { b as IWorkspaceFolder, I as IAnyWorkspaceIdentifier, c as IWorkspaceContextService } from './workspace.js';
+import { c as IStringDictionary, d as IExtensionInfo, C as ConfigurationScope, E as EditPresentationTypes } from './configurationRegistry.js';
+import { P as PlatformName, O as OperatingSystem } from './platform.js';
 import { I as ILogService } from './log.js';
 export { a as ILoggerService, L as LogLevel } from './log.js';
-import { I as IWorkspaceFolder } from './workspace.js';
-export { a as IWorkspaceContextService } from './workspace.js';
-import { R as ResolvedKeybinding } from './keybinding.js';
-import { I as ITextBufferFactory, a as ITextModel, b as ITextModelCreationOptions, c as IEditor, d as IDiffEditor, e as IRange, f as IPosition, P as Position, g as IDocumentDiffProviderOptions, h as IDocumentDiff, i as IChange, j as ICodeEditor, k as IDiffEditor$1, l as IDecorationRenderOptions, m as IModelDecorationOptions } from './editorBrowser.js';
-export { n as ITextModelContentProvider, o as ITextModelService } from './editorBrowser.js';
+import { R as ResolvedKeybinding, K as KeyCode, a as KeyCodeChord, b as IKeybindingService, c as ResolvedKeybindingItem } from './keybinding.js';
+import { I as IconIdentifier, T as ThemeIcon } from './themables.js';
+import { I as IJSONSchema, a as IJSONSchemaMap } from './jsonSchema.js';
+import { I as IView$3, a as IViewDescriptorService, b as IViewPaneContainer, c as ViewContainer, d as IViewContainerModel, e as IViewDescriptor, f as IAddedViewDescriptorRef, g as IPaneComposite, V as ViewContainerLocation } from './views.js';
+export { h as IViewsService } from './views.js';
+import { e as ICommandAction, f as ICommandActionTitle, g as Icon, h as IEnvironmentService, E as ExtensionIdentifier, T as TargetPlatform, a as IExtensionDescription } from './extensions.d2.ts';
+import { b as IProgress, c as IProgressStep, I as IComposite, d as ICompositeControl, a as IProgressIndicator } from './composite.js';
+import { a as IContextKeyService, C as ContextKeyExpression } from './contextkey.js';
+import { a as IExtensionService } from './extensionsRegistry.js';
 import { I as IEditorOverrideServices } from './standaloneServices.js';
 export { S as StandaloneServices } from './standaloneServices.js';
 import 'vscode';
-import './jsonSchema.js';
-import './contextkey.js';
-import './themables.js';
-import './extensionsRegistry.js';
 import 'monaco-editor';
 
 interface IAccessibilityInformation {
@@ -36,6 +33,161 @@ interface IAccessibilityInformation {
     role?: string;
 }
 
+interface IConfigurationOverrides {
+    overrideIdentifier?: string | null;
+    resource?: URI | null;
+}
+type IConfigurationUpdateOverrides = Omit<IConfigurationOverrides, 'overrideIdentifier'> & {
+    overrideIdentifiers?: string[] | null;
+};
+declare const enum ConfigurationTarget {
+    APPLICATION = 1,
+    USER = 2,
+    USER_LOCAL = 3,
+    USER_REMOTE = 4,
+    WORKSPACE = 5,
+    WORKSPACE_FOLDER = 6,
+    DEFAULT = 7,
+    MEMORY = 8
+}
+interface IConfigurationChange {
+    keys: string[];
+    overrides: [string, string[]][];
+}
+interface IConfigurationChangeEvent {
+    readonly source: ConfigurationTarget;
+    readonly affectedKeys: ReadonlySet<string>;
+    readonly change: IConfigurationChange;
+    affectsConfiguration(configuration: string, overrides?: IConfigurationOverrides): boolean;
+    readonly sourceConfig: any;
+}
+interface IConfigurationValue<T> {
+    readonly defaultValue?: T;
+    readonly applicationValue?: T;
+    readonly userValue?: T;
+    readonly userLocalValue?: T;
+    readonly userRemoteValue?: T;
+    readonly workspaceValue?: T;
+    readonly workspaceFolderValue?: T;
+    readonly memoryValue?: T;
+    readonly policyValue?: T;
+    readonly value?: T;
+    readonly default?: {
+        value?: T;
+        override?: T;
+    };
+    readonly application?: {
+        value?: T;
+        override?: T;
+    };
+    readonly user?: {
+        value?: T;
+        override?: T;
+    };
+    readonly userLocal?: {
+        value?: T;
+        override?: T;
+    };
+    readonly userRemote?: {
+        value?: T;
+        override?: T;
+    };
+    readonly workspace?: {
+        value?: T;
+        override?: T;
+    };
+    readonly workspaceFolder?: {
+        value?: T;
+        override?: T;
+    };
+    readonly memory?: {
+        value?: T;
+        override?: T;
+    };
+    readonly policy?: {
+        value?: T;
+    };
+    readonly overrideIdentifiers?: string[];
+}
+interface IConfigurationUpdateOptions {
+    /**
+     * If `true`, do not notifies the error to user by showing the message box. Default is `false`.
+     */
+    donotNotifyError?: boolean;
+    /**
+     * How to handle dirty file when updating the configuration.
+     */
+    handleDirtyFile?: 'save' | 'revert';
+}
+
+declare const IConfigurationService: ServiceIdentifier<IConfigurationService>;
+interface IConfigurationService {
+    readonly _serviceBrand: undefined;
+    onDidChangeConfiguration: Event$1<IConfigurationChangeEvent>;
+    getConfigurationData(): IConfigurationData | null;
+    /**
+     * Fetches the value of the section for the given overrides.
+     * Value can be of native type or an object keyed off the section name.
+     *
+     * @param section - Section of the configuration. Can be `null` or `undefined`.
+     * @param overrides - Overrides that has to be applied while fetching
+     *
+     */
+    getValue<T>(): T;
+    getValue<T>(section: string): T;
+    getValue<T>(overrides: IConfigurationOverrides): T;
+    getValue<T>(section: string, overrides: IConfigurationOverrides): T;
+    /**
+     * Update a configuration value.
+     *
+     * Use `target` to update the configuration in a specific `ConfigurationTarget`.
+     *
+     * Use `overrides` to update the configuration for a resource or for override identifiers or both.
+     *
+     * Passing a resource through overrides will update the configuration in the workspace folder containing that resource.
+     *
+     * *Note 1:* Updating configuration to a default value will remove the configuration from the requested target. If not target is passed, it will be removed from all writeable targets.
+     *
+     * *Note 2:* Use `undefined` value to remove the configuration from the given target. If not target is passed, it will be removed from all writeable targets.
+     *
+     * Use `donotNotifyError` and set it to `true` to surpresss errors.
+     *
+     * @param key setting to be updated
+     * @param value The new value
+     */
+    updateValue(key: string, value: any): Promise<void>;
+    updateValue(key: string, value: any, target: ConfigurationTarget): Promise<void>;
+    updateValue(key: string, value: any, overrides: IConfigurationOverrides | IConfigurationUpdateOverrides): Promise<void>;
+    updateValue(key: string, value: any, overrides: IConfigurationOverrides | IConfigurationUpdateOverrides, target: ConfigurationTarget, options?: IConfigurationUpdateOptions): Promise<void>;
+    inspect<T>(key: string, overrides?: IConfigurationOverrides): IConfigurationValue<Readonly<T>>;
+    reloadConfiguration(target?: ConfigurationTarget | IWorkspaceFolder): Promise<void>;
+    keys(): {
+        default: string[];
+        user: string[];
+        workspace: string[];
+        workspaceFolder: string[];
+        memory?: string[];
+    };
+}
+interface IConfigurationModel {
+    contents: any;
+    keys: string[];
+    overrides: IOverrides[];
+}
+interface IOverrides {
+    keys: string[];
+    contents: any;
+    identifiers: string[];
+}
+interface IConfigurationData {
+    defaults: IConfigurationModel;
+    policy: IConfigurationModel;
+    application: IConfigurationModel;
+    user: IConfigurationModel;
+    workspace: IConfigurationModel;
+    folders: [UriComponents, IConfigurationModel][];
+}
+
 interface ILanguageExtensionPoint {
     id: string;
     extensions?: string[];
@@ -52,7 +204,7 @@ interface ILanguageExtensionPoint {
 }
 interface ILanguageSelection {
     readonly languageId: string;
-    readonly onDidChange: Event<string>;
+    readonly onDidChange: Event$1<string>;
 }
 interface ILanguageNameIdPair {
     readonly languageName: string;
@@ -78,7 +230,7 @@ interface ILanguageService {
      * **Note**: Basic language features refers to language configuration related features.
      * **Note**: This event is a superset of `onDidRequestRichLanguageFeatures`
      */
-    onDidRequestBasicLanguageFeatures: Event<string>;
+    onDidRequestBasicLanguageFeatures: Event$1<string>;
     /**
      * An event emitted when rich language features are requested for the first time.
      * This event is emitted when a language is associated to a text model.
@@ -86,11 +238,11 @@ interface ILanguageService {
      * **Note**: Rich language features refers to tokenizers, language features based on providers, etc.
      * **Note**: This event is a subset of `onDidRequestRichLanguageFeatures`
      */
-    onDidRequestRichLanguageFeatures: Event<string>;
+    onDidRequestRichLanguageFeatures: Event$1<string>;
     /**
      * An event emitted when languages have changed.
      */
-    onDidChange: Event<void>;
+    onDidChange: Event$1<void>;
     /**
      * Register a language.
      */
@@ -176,11 +328,231 @@ declare class UndoRedoSource {
     static None: UndoRedoSource;
 }
 
-type PlatformName = 'Web' | 'Windows' | 'Mac' | 'Linux';
-declare const enum OperatingSystem {
-    Windows = 1,
-    Macintosh = 2,
-    Linux = 3
+interface ISubmenuItem {
+    title: string | ICommandActionTitle;
+    submenu: MenuId;
+    icon?: Icon;
+    when?: ContextKeyExpression;
+    group?: 'navigation' | string;
+    order?: number;
+    isSelection?: boolean;
+    rememberDefaultAction?: boolean;
+}
+declare class MenuId {
+    private static readonly _instances;
+    static readonly CommandPalette: MenuId;
+    static readonly DebugBreakpointsContext: MenuId;
+    static readonly DebugCallStackContext: MenuId;
+    static readonly DebugConsoleContext: MenuId;
+    static readonly DebugVariablesContext: MenuId;
+    static readonly DebugWatchContext: MenuId;
+    static readonly DebugToolBar: MenuId;
+    static readonly DebugToolBarStop: MenuId;
+    static readonly EditorContext: MenuId;
+    static readonly SimpleEditorContext: MenuId;
+    static readonly EditorContent: MenuId;
+    static readonly EditorLineNumberContext: MenuId;
+    static readonly EditorContextCopy: MenuId;
+    static readonly EditorContextPeek: MenuId;
+    static readonly EditorContextShare: MenuId;
+    static readonly EditorTitle: MenuId;
+    static readonly EditorTitleRun: MenuId;
+    static readonly EditorTitleContext: MenuId;
+    static readonly EditorTitleContextShare: MenuId;
+    static readonly EmptyEditorGroup: MenuId;
+    static readonly EmptyEditorGroupContext: MenuId;
+    static readonly EditorTabsBarContext: MenuId;
+    static readonly ExplorerContext: MenuId;
+    static readonly ExplorerContextShare: MenuId;
+    static readonly ExtensionContext: MenuId;
+    static readonly GlobalActivity: MenuId;
+    static readonly CommandCenter: MenuId;
+    static readonly LayoutControlMenuSubmenu: MenuId;
+    static readonly LayoutControlMenu: MenuId;
+    static readonly MenubarMainMenu: MenuId;
+    static readonly MenubarAppearanceMenu: MenuId;
+    static readonly MenubarDebugMenu: MenuId;
+    static readonly MenubarEditMenu: MenuId;
+    static readonly MenubarCopy: MenuId;
+    static readonly MenubarFileMenu: MenuId;
+    static readonly MenubarGoMenu: MenuId;
+    static readonly MenubarHelpMenu: MenuId;
+    static readonly MenubarLayoutMenu: MenuId;
+    static readonly MenubarNewBreakpointMenu: MenuId;
+    static readonly PanelAlignmentMenu: MenuId;
+    static readonly PanelPositionMenu: MenuId;
+    static readonly MenubarPreferencesMenu: MenuId;
+    static readonly MenubarRecentMenu: MenuId;
+    static readonly MenubarSelectionMenu: MenuId;
+    static readonly MenubarShare: MenuId;
+    static readonly MenubarSwitchEditorMenu: MenuId;
+    static readonly MenubarSwitchGroupMenu: MenuId;
+    static readonly MenubarTerminalMenu: MenuId;
+    static readonly MenubarViewMenu: MenuId;
+    static readonly MenubarHomeMenu: MenuId;
+    static readonly OpenEditorsContext: MenuId;
+    static readonly OpenEditorsContextShare: MenuId;
+    static readonly ProblemsPanelContext: MenuId;
+    static readonly SCMChangeContext: MenuId;
+    static readonly SCMResourceContext: MenuId;
+    static readonly SCMResourceContextShare: MenuId;
+    static readonly SCMResourceFolderContext: MenuId;
+    static readonly SCMResourceGroupContext: MenuId;
+    static readonly SCMSourceControl: MenuId;
+    static readonly SCMTitle: MenuId;
+    static readonly SearchContext: MenuId;
+    static readonly SearchActionMenu: MenuId;
+    static readonly StatusBarWindowIndicatorMenu: MenuId;
+    static readonly StatusBarRemoteIndicatorMenu: MenuId;
+    static readonly StickyScrollContext: MenuId;
+    static readonly TestItem: MenuId;
+    static readonly TestItemGutter: MenuId;
+    static readonly TestPeekElement: MenuId;
+    static readonly TestPeekTitle: MenuId;
+    static readonly TouchBarContext: MenuId;
+    static readonly TitleBarContext: MenuId;
+    static readonly TitleBarTitleContext: MenuId;
+    static readonly TunnelContext: MenuId;
+    static readonly TunnelPrivacy: MenuId;
+    static readonly TunnelProtocol: MenuId;
+    static readonly TunnelPortInline: MenuId;
+    static readonly TunnelTitle: MenuId;
+    static readonly TunnelLocalAddressInline: MenuId;
+    static readonly TunnelOriginInline: MenuId;
+    static readonly ViewItemContext: MenuId;
+    static readonly ViewContainerTitle: MenuId;
+    static readonly ViewContainerTitleContext: MenuId;
+    static readonly ViewTitle: MenuId;
+    static readonly ViewTitleContext: MenuId;
+    static readonly CommentEditorActions: MenuId;
+    static readonly CommentThreadTitle: MenuId;
+    static readonly CommentThreadActions: MenuId;
+    static readonly CommentThreadAdditionalActions: MenuId;
+    static readonly CommentThreadTitleContext: MenuId;
+    static readonly CommentThreadCommentContext: MenuId;
+    static readonly CommentTitle: MenuId;
+    static readonly CommentActions: MenuId;
+    static readonly InteractiveToolbar: MenuId;
+    static readonly InteractiveCellTitle: MenuId;
+    static readonly InteractiveCellDelete: MenuId;
+    static readonly InteractiveCellExecute: MenuId;
+    static readonly InteractiveInputExecute: MenuId;
+    static readonly NotebookToolbar: MenuId;
+    static readonly NotebookCellTitle: MenuId;
+    static readonly NotebookCellDelete: MenuId;
+    static readonly NotebookCellInsert: MenuId;
+    static readonly NotebookCellBetween: MenuId;
+    static readonly NotebookCellListTop: MenuId;
+    static readonly NotebookCellExecute: MenuId;
+    static readonly NotebookCellExecutePrimary: MenuId;
+    static readonly NotebookDiffCellInputTitle: MenuId;
+    static readonly NotebookDiffCellMetadataTitle: MenuId;
+    static readonly NotebookDiffCellOutputsTitle: MenuId;
+    static readonly NotebookOutputToolbar: MenuId;
+    static readonly NotebookEditorLayoutConfigure: MenuId;
+    static readonly NotebookKernelSource: MenuId;
+    static readonly BulkEditTitle: MenuId;
+    static readonly BulkEditContext: MenuId;
+    static readonly TimelineItemContext: MenuId;
+    static readonly TimelineTitle: MenuId;
+    static readonly TimelineTitleContext: MenuId;
+    static readonly TimelineFilterSubMenu: MenuId;
+    static readonly AccountsContext: MenuId;
+    static readonly PanelTitle: MenuId;
+    static readonly AuxiliaryBarTitle: MenuId;
+    static readonly TerminalInstanceContext: MenuId;
+    static readonly TerminalEditorInstanceContext: MenuId;
+    static readonly TerminalNewDropdownContext: MenuId;
+    static readonly TerminalTabContext: MenuId;
+    static readonly TerminalTabEmptyAreaContext: MenuId;
+    static readonly TerminalInlineTabContext: MenuId;
+    static readonly WebviewContext: MenuId;
+    static readonly InlineCompletionsActions: MenuId;
+    static readonly NewFile: MenuId;
+    static readonly MergeInput1Toolbar: MenuId;
+    static readonly MergeInput2Toolbar: MenuId;
+    static readonly MergeBaseToolbar: MenuId;
+    static readonly MergeInputResultToolbar: MenuId;
+    static readonly InlineSuggestionToolbar: MenuId;
+    static readonly ChatContext: MenuId;
+    static readonly ChatCodeBlock: MenuId;
+    static readonly ChatMessageTitle: MenuId;
+    static readonly ChatExecute: MenuId;
+    /**
+     * Create or reuse a `MenuId` with the given identifier
+     */
+    static for(identifier: string): MenuId;
+    readonly id: string;
+    /**
+     * Create a new `MenuId` with the unique identifier. Will throw if a menu
+     * with the identifier already exists, use `MenuId.for(ident)` or a unique
+     * identifier
+     */
+    constructor(identifier: string);
+}
+interface IMenuActionOptions {
+    arg?: any;
+    shouldForwardArgs?: boolean;
+    renderShortTitle?: boolean;
+}
+interface IMenuChangeEvent {
+    readonly menu: IMenu;
+    readonly isStructuralChange: boolean;
+    readonly isToggleChange: boolean;
+    readonly isEnablementChange: boolean;
+}
+interface IMenu extends IDisposable {
+    readonly onDidChange: Event$1<IMenuChangeEvent>;
+    getActions(options?: IMenuActionOptions): [string, Array<MenuItemAction | SubmenuItemAction>][];
+}
+interface IMenuCreateOptions {
+    emitEventsForSubmenuChanges?: boolean;
+    eventDebounceDelay?: number;
+}
+declare const IMenuService: ServiceIdentifier<IMenuService>;
+interface IMenuService {
+    readonly _serviceBrand: undefined;
+    /**
+     * Create a new menu for the given menu identifier. A menu sends events when it's entries
+     * have changed (placement, enablement, checked-state). By default it does not send events for
+     * submenu entries. That is more expensive and must be explicitly enabled with the
+     * `emitEventsForSubmenuChanges` flag.
+     */
+    createMenu(id: MenuId, contextKeyService: IContextKeyService, options?: IMenuCreateOptions): IMenu;
+    /**
+     * Reset **all** menu item hidden states.
+     */
+    resetHiddenStates(): void;
+    /**
+     * Reset the menu's hidden states.
+     */
+    resetHiddenStates(menuIds: readonly MenuId[] | undefined): void;
+}
+declare class SubmenuItemAction extends SubmenuAction {
+    readonly item: ISubmenuItem;
+    readonly hideActions: IMenuItemHide | undefined;
+    constructor(item: ISubmenuItem, hideActions: IMenuItemHide | undefined, actions: IAction[]);
+}
+interface IMenuItemHide {
+    readonly isHidden: boolean;
+    readonly hide: IAction;
+    readonly toggle: IAction;
+}
+declare class MenuItemAction implements IAction {
+    readonly hideActions: IMenuItemHide | undefined;
+    private _commandService;
+    static label(action: ICommandAction, options?: IMenuActionOptions): string;
+    readonly item: ICommandAction;
+    readonly alt: MenuItemAction | undefined;
+    private readonly _options;
+    readonly id: string;
+    readonly label: string;
+    readonly tooltip: string;
+    readonly class: string | undefined;
+    readonly enabled: boolean;
+    readonly checked?: boolean;
+    constructor(item: ICommandAction, alt: ICommandAction | undefined, options: IMenuActionOptions | undefined, hideActions: IMenuItemHide | undefined, contextKeyService: IContextKeyService, _commandService: ICommandService);
+    run(...args: any[]): Promise<void>;
 }
 
 interface IExtUri {
@@ -320,6 +692,225 @@ interface IUriIdentityService {
     asCanonicalUri(uri: URI): URI;
 }
 
+/**
+ * Flags to indicate whether to use the default profile or not.
+ */
+type UseDefaultProfileFlags = {
+    settings?: boolean;
+    keybindings?: boolean;
+    tasks?: boolean;
+    snippets?: boolean;
+    extensions?: boolean;
+    uiState?: boolean;
+};
+interface IUserDataProfile {
+    readonly id: string;
+    readonly isDefault: boolean;
+    readonly name: string;
+    readonly shortName?: string;
+    readonly location: URI;
+    readonly globalStorageHome: URI;
+    readonly settingsResource: URI;
+    readonly keybindingsResource: URI;
+    readonly tasksResource: URI;
+    readonly snippetsHome: URI;
+    readonly extensionsResource: URI;
+    readonly cacheHome: URI;
+    readonly useDefaultFlags?: UseDefaultProfileFlags;
+    readonly isTransient?: boolean;
+}
+
+declare enum WillSaveStateReason {
+    /**
+     * No specific reason to save state.
+     */
+    NONE = 0,
+    /**
+     * A hint that the workbench is about to shutdown.
+     */
+    SHUTDOWN = 1
+}
+interface IWillSaveStateEvent {
+    readonly reason: WillSaveStateReason;
+}
+declare const IStorageService: ServiceIdentifier<IStorageService>;
+interface IStorageService {
+    readonly _serviceBrand: undefined;
+    /**
+     * Emitted whenever data is updated or deleted.
+     */
+    readonly onDidChangeValue: Event$1<IStorageValueChangeEvent>;
+    /**
+     * Emitted whenever target of a storage entry changes.
+     */
+    readonly onDidChangeTarget: Event$1<IStorageTargetChangeEvent>;
+    /**
+     * Emitted when the storage is about to persist. This is the right time
+     * to persist data to ensure it is stored before the application shuts
+     * down.
+     *
+     * The will save state event allows to optionally ask for the reason of
+     * saving the state, e.g. to find out if the state is saved due to a
+     * shutdown.
+     *
+     * Note: this event may be fired many times, not only on shutdown to prevent
+     * loss of state in situations where the shutdown is not sufficient to
+     * persist the data properly.
+     */
+    readonly onWillSaveState: Event$1<IWillSaveStateEvent>;
+    /**
+     * Retrieve an element stored with the given key from storage. Use
+     * the provided `defaultValue` if the element is `null` or `undefined`.
+     *
+     * @param scope allows to define the scope of the storage operation
+     * to either the current workspace only, all workspaces or all profiles.
+     */
+    get(key: string, scope: StorageScope, fallbackValue: string): string;
+    get(key: string, scope: StorageScope, fallbackValue?: string): string | undefined;
+    /**
+     * Retrieve an element stored with the given key from storage. Use
+     * the provided `defaultValue` if the element is `null` or `undefined`.
+     * The element will be converted to a `boolean`.
+     *
+     * @param scope allows to define the scope of the storage operation
+     * to either the current workspace only, all workspaces or all profiles.
+     */
+    getBoolean(key: string, scope: StorageScope, fallbackValue: boolean): boolean;
+    getBoolean(key: string, scope: StorageScope, fallbackValue?: boolean): boolean | undefined;
+    /**
+     * Retrieve an element stored with the given key from storage. Use
+     * the provided `defaultValue` if the element is `null` or `undefined`.
+     * The element will be converted to a `number` using `parseInt` with a
+     * base of `10`.
+     *
+     * @param scope allows to define the scope of the storage operation
+     * to either the current workspace only, all workspaces or all profiles.
+     */
+    getNumber(key: string, scope: StorageScope, fallbackValue: number): number;
+    getNumber(key: string, scope: StorageScope, fallbackValue?: number): number | undefined;
+    /**
+     * Retrieve an element stored with the given key from storage. Use
+     * the provided `defaultValue` if the element is `null` or `undefined`.
+     * The element will be converted to a `object` using `JSON.parse`.
+     *
+     * @param scope allows to define the scope of the storage operation
+     * to either the current workspace only, all workspaces or all profiles.
+     */
+    getObject<T extends object>(key: string, scope: StorageScope, fallbackValue: T): T;
+    getObject<T extends object>(key: string, scope: StorageScope, fallbackValue?: T): T | undefined;
+    /**
+     * Store a value under the given key to storage. The value will be
+     * converted to a `string`. Storing either `undefined` or `null` will
+     * remove the entry under the key.
+     *
+     * @param scope allows to define the scope of the storage operation
+     * to either the current workspace only, all workspaces or all profiles.
+     *
+     * @param target allows to define the target of the storage operation
+     * to either the current machine or user.
+     */
+    store(key: string, value: string | boolean | number | undefined | null | object, scope: StorageScope, target: StorageTarget): void;
+    /**
+     * Delete an element stored under the provided key from storage.
+     *
+     * The scope argument allows to define the scope of the storage
+     * operation to either the current workspace only, all workspaces
+     * or all profiles.
+     */
+    remove(key: string, scope: StorageScope): void;
+    /**
+     * Returns all the keys used in the storage for the provided `scope`
+     * and `target`.
+     *
+     * Note: this will NOT return all keys stored in the storage layer.
+     * Some keys may not have an associated `StorageTarget` and thus
+     * will be excluded from the results.
+     *
+     * @param scope allows to define the scope for the keys
+     * to either the current workspace only, all workspaces or all profiles.
+     *
+     * @param target allows to define the target for the keys
+     * to either the current machine or user.
+     */
+    keys(scope: StorageScope, target: StorageTarget): string[];
+    /**
+     * Log the contents of the storage to the console.
+     */
+    log(): void;
+    /**
+     * Returns true if the storage service handles the provided scope.
+     */
+    hasScope(scope: IAnyWorkspaceIdentifier | IUserDataProfile): boolean;
+    /**
+     * Switch storage to another workspace or profile. Optionally preserve the
+     * current data to the new storage.
+     */
+    switch(to: IAnyWorkspaceIdentifier | IUserDataProfile, preserveData: boolean): Promise<void>;
+    /**
+     * Whether the storage for the given scope was created during this session or
+     * existed before.
+     */
+    isNew(scope: StorageScope): boolean;
+    /**
+     * Allows to flush state, e.g. in cases where a shutdown is
+     * imminent. This will send out the `onWillSaveState` to ask
+     * everyone for latest state.
+     *
+     * @returns a `Promise` that can be awaited on when all updates
+     * to the underlying storage have been flushed.
+     */
+    flush(reason?: WillSaveStateReason): Promise<void>;
+}
+declare const enum StorageScope {
+    /**
+     * The stored data will be scoped to all workspaces across all profiles.
+     */
+    APPLICATION = -1,
+    /**
+     * The stored data will be scoped to all workspaces of the same profile.
+     */
+    PROFILE = 0,
+    /**
+     * The stored data will be scoped to the current workspace.
+     */
+    WORKSPACE = 1
+}
+declare const enum StorageTarget {
+    /**
+     * The stored data is user specific and applies across machines.
+     */
+    USER = 0,
+    /**
+     * The stored data is machine specific.
+     */
+    MACHINE = 1
+}
+interface IStorageValueChangeEvent {
+    /**
+     * The scope for the storage entry that changed
+     * or was removed.
+     */
+    readonly scope: StorageScope;
+    /**
+     * The `key` of the storage entry that was changed
+     * or was removed.
+     */
+    readonly key: string;
+    /**
+     * The `target` can be `undefined` if a key is being
+     * removed.
+     */
+    readonly target: StorageTarget | undefined;
+}
+interface IStorageTargetChangeEvent {
+    /**
+     * The scope for the target that changed. Listeners
+     * should use `keys(scope, target)` to get an updated
+     * list of keys for the given `scope` and `target`.
+     */
+    readonly scope: StorageScope;
+}
+
 interface IBuiltInExtension {
     readonly name: string;
     readonly version: string;
@@ -504,6 +1095,7 @@ interface IProductConfiguration {
     readonly 'editSessions.store'?: Omit<ConfigurationSyncStore, 'insidersUrl' | 'stableUrl'>;
     readonly darwinUniversalAssetId?: string;
     readonly profileTemplatesUrl?: string;
+    readonly commonlyUsedSettings?: string[];
 }
 interface ITunnelApplicationConfig {
     authenticationProviders: IStringDictionary<{
@@ -514,6 +1106,10 @@ interface ITunnelApplicationConfig {
 }
 interface IExtensionRecommendations {
     readonly onFileOpen: IFileOpenCondition[];
+    readonly onSettingsEditorOpen?: ISettingsEditorOpenCondition;
+}
+interface ISettingsEditorOpenCondition {
+    readonly prerelease: boolean | string;
 }
 interface IExtensionRecommendationCondition {
     readonly important?: boolean;
@@ -563,13 +1159,23 @@ interface IRemoteExtensionTip {
     friendlyName: string;
     extensionId: string;
     supportedPlatforms?: PlatformName[];
-    showInStartEntry?: boolean;
+    startEntry?: {
+        helpLink: string;
+        startConnectLabel: string;
+        startCommand: string;
+        priority: number;
+    };
 }
 interface IVirtualWorkspaceExtensionTip {
     friendlyName: string;
     extensionId: string;
     supportedPlatforms?: PlatformName[];
-    showInStartEntry?: boolean;
+    startEntry: {
+        helpLink: string;
+        startConnectLabel: string;
+        startCommand: string;
+        priority: number;
+    };
 }
 interface ISurveyData {
     surveyId: string;
@@ -784,10 +1390,14 @@ interface IQuickInputHideEvent {
     reason: QuickInputHideReason;
 }
 interface IQuickInput extends IDisposable {
-    readonly onDidHide: Event<IQuickInputHideEvent>;
-    readonly onDispose: Event<void>;
+    readonly onDidHide: Event$1<IQuickInputHideEvent>;
+    readonly onDispose: Event$1<void>;
     title: string | undefined;
     description: string | undefined;
+    /**
+     * Should be an HTMLElement (TODO: move this entire file into browser)
+     */
+    widget: any | undefined;
     step: number | undefined;
     totalSteps: number | undefined;
     enabled: boolean;
@@ -827,9 +1437,9 @@ interface IQuickPick<T extends IQuickPickItem> extends IQuickInput {
     filterValue: (value: string) => string;
     ariaLabel: string | undefined;
     placeholder: string | undefined;
-    readonly onDidChangeValue: Event<string>;
-    readonly onWillAccept: Event<IQuickPickWillAcceptEvent>;
-    readonly onDidAccept: Event<IQuickPickDidAcceptEvent>;
+    readonly onDidChangeValue: Event$1<string>;
+    readonly onWillAccept: Event$1<IQuickPickWillAcceptEvent>;
+    readonly onDidAccept: Event$1<IQuickPickDidAcceptEvent>;
     /**
      * If enabled, will fire the `onDidAccept` event when
      * pressing the arrow-right key with the idea of accepting
@@ -837,14 +1447,14 @@ interface IQuickPick<T extends IQuickPickItem> extends IQuickInput {
      */
     canAcceptInBackground: boolean;
     ok: boolean | 'default';
-    readonly onDidCustom: Event<void>;
+    readonly onDidCustom: Event$1<void>;
     customButton: boolean;
     customLabel: string | undefined;
     customHover: string | undefined;
     buttons: ReadonlyArray<IQuickInputButton>;
-    readonly onDidTriggerButton: Event<IQuickInputButton>;
-    readonly onDidTriggerItemButton: Event<IQuickPickItemButtonEvent<T>>;
-    readonly onDidTriggerSeparatorButton: Event<IQuickPickSeparatorButtonEvent>;
+    readonly onDidTriggerButton: Event$1<IQuickInputButton>;
+    readonly onDidTriggerItemButton: Event$1<IQuickPickItemButtonEvent<T>>;
+    readonly onDidTriggerSeparatorButton: Event$1<IQuickPickSeparatorButtonEvent>;
     items: ReadonlyArray<T | IQuickPickSeparator>;
     scrollTop: number;
     canSelectMany: boolean;
@@ -862,13 +1472,13 @@ interface IQuickPick<T extends IQuickPickItem> extends IQuickInput {
     keepScrollPosition: boolean;
     quickNavigate: IQuickNavigateConfiguration | undefined;
     activeItems: ReadonlyArray<T>;
-    readonly onDidChangeActive: Event<T[]>;
+    readonly onDidChangeActive: Event$1<T[]>;
     /**
      * Allows to control which entry should be activated by default.
      */
     itemActivation: ItemActivation;
     selectedItems: ReadonlyArray<T>;
-    readonly onDidChangeSelection: Event<T[]>;
+    readonly onDidChangeSelection: Event$1<T[]>;
     readonly keyMods: IKeyMods;
     valueSelection: Readonly<[number, number]> | undefined;
     validationMessage: string | undefined;
@@ -887,7 +1497,7 @@ interface IQuickPick<T extends IQuickPickItem> extends IQuickInput {
     toggles: IQuickInputToggle[] | undefined;
 }
 interface IQuickInputToggle {
-    onChange: Event<boolean>;
+    onChange: Event$1<boolean>;
 }
 interface IInputBox extends IQuickInput {
     /**
@@ -909,11 +1519,11 @@ interface IInputBox extends IQuickInput {
     /**
      * Event called when the input value changes.
      */
-    readonly onDidChangeValue: Event<string>;
+    readonly onDidChangeValue: Event$1<string>;
     /**
      * Event called when the user submits the input.
      */
-    readonly onDidAccept: Event<void>;
+    readonly onDidAccept: Event$1<void>;
     /**
      * Buttons to show in addition to user input submission.
      */
@@ -921,7 +1531,7 @@ interface IInputBox extends IQuickInput {
     /**
      * Event called when a button is selected.
      */
-    readonly onDidTriggerButton: Event<IQuickInputButton>;
+    readonly onDidTriggerButton: Event$1<IQuickInputButton>;
     /**
      * Text show below the input box.
      */
@@ -978,11 +1588,11 @@ interface IQuickInputService {
     /**
      * Allows to register on the event that quick input is showing.
      */
-    readonly onShow: Event<void>;
+    readonly onShow: Event$1<void>;
     /**
      * Allows to register on the event that quick input is hiding.
      */
-    readonly onHide: Event<void>;
+    readonly onHide: Event$1<void>;
     /**
      * Opens the quick input box for selecting items and returns a promise
      * with the user selected item(s) if any.
@@ -1035,6 +1645,105 @@ interface IQuickInputService {
     cancel(): Promise<void>;
 }
 
+interface IPropertyData {
+    classification: 'SystemMetaData' | 'CallstackOrException' | 'CustomerContent' | 'PublicNonPersonalData' | 'EndUserPseudonymizedInformation';
+    purpose: 'PerformanceAndHealth' | 'FeatureInsight' | 'BusinessInsight';
+    comment: string;
+    expiration?: string;
+    endpoint?: string;
+    isMeasurement?: boolean;
+}
+interface IGDPRProperty {
+    owner: string;
+    comment: string;
+    expiration?: string;
+    readonly [name: string]: IPropertyData | undefined | IGDPRProperty | string;
+}
+type IGDPRPropertyWithoutMetadata = Omit<IGDPRProperty, 'owner' | 'comment' | 'expiration'>;
+type OmitMetadata<T> = Omit<T, 'owner' | 'comment' | 'expiration'>;
+type ClassifiedEvent<T extends IGDPRPropertyWithoutMetadata> = {
+    [k in keyof T]: any;
+};
+type StrictPropertyChecker<TEvent, TClassification, TError> = keyof TEvent extends keyof OmitMetadata<TClassification> ? keyof OmitMetadata<TClassification> extends keyof TEvent ? TEvent : TError : TError;
+type StrictPropertyCheckError = {
+    error: 'Type of classified event does not match event properties';
+};
+type StrictPropertyCheck<T extends IGDPRProperty, E> = StrictPropertyChecker<E, ClassifiedEvent<OmitMetadata<T>>, StrictPropertyCheckError>;
+
+interface ITelemetryData {
+    from?: string;
+    target?: string;
+    [key: string]: any;
+}
+
+declare const ITelemetryService: ServiceIdentifier<ITelemetryService>;
+interface ITelemetryService {
+    readonly _serviceBrand: undefined;
+    readonly telemetryLevel: TelemetryLevel;
+    readonly sessionId: string;
+    readonly machineId: string;
+    readonly firstSessionDate: string;
+    readonly msftInternal?: boolean;
+    /**
+     * Whether error telemetry will get sent. If false, `publicLogError` will no-op.
+     */
+    readonly sendErrorTelemetry: boolean;
+    /**
+     * @deprecated Use publicLog2 and the typescript GDPR annotation where possible
+     */
+    publicLog(eventName: string, data?: ITelemetryData): void;
+    /**
+     * Sends a telemetry event that has been privacy approved.
+     * Do not call this unless you have been given approval.
+     */
+    publicLog2<E extends ClassifiedEvent<OmitMetadata<T>> = never, T extends IGDPRProperty = never>(eventName: string, data?: StrictPropertyCheck<T, E>): void;
+    /**
+     * @deprecated Use publicLogError2 and the typescript GDPR annotation where possible
+     */
+    publicLogError(errorEventName: string, data?: ITelemetryData): void;
+    publicLogError2<E extends ClassifiedEvent<OmitMetadata<T>> = never, T extends IGDPRProperty = never>(eventName: string, data?: StrictPropertyCheck<T, E>): void;
+    setExperimentProperty(name: string, value: string): void;
+}
+interface ITelemetryEndpoint {
+    id: string;
+    aiKey: string;
+    sendErrorTelemetry: boolean;
+}
+declare const enum TelemetryLevel {
+    NONE = 0,
+    CRASH = 1,
+    ERROR = 2,
+    USAGE = 3
+}
+
+/**
+ * The editor model is the heavyweight counterpart of editor input. Depending on the editor input, it
+ * resolves from a file system retrieve content and may allow for saving it back or reverting it.
+ * Editor models are typically cached for some while because they are expensive to construct.
+ */
+declare class EditorModel extends Disposable implements IEditorModel {
+    private readonly _onWillDispose;
+    readonly onWillDispose: Event$1<void>;
+    private disposed;
+    private resolved;
+    /**
+     * Causes this model to resolve returning a promise when loading is completed.
+     */
+    resolve(): Promise<void>;
+    /**
+     * Returns whether this model was loaded or not.
+     */
+    isResolved(): boolean;
+    /**
+     * Find out if this model has been disposed.
+     */
+    isDisposed(): boolean;
+    /**
+     * Subclasses should implement to free resources that have been claimed through loading.
+     */
+    dispose(): void;
+}
+
 declare const IModelService: ServiceIdentifier<IModelService>;
 interface IModelService {
     readonly _serviceBrand: undefined;
@@ -1044,9 +1753,9 @@ interface IModelService {
     getModels(): ITextModel[];
     getCreationOptions(language: string, resource: URI, isForSimpleWidget: boolean): ITextModelCreationOptions;
     getModel(resource: URI): ITextModel | null;
-    onModelAdded: Event<ITextModel>;
-    onModelRemoved: Event<ITextModel>;
-    onModelLanguageChanged: Event<{
+    onModelAdded: Event$1<ITextModel>;
+    onModelRemoved: Event$1<ITextModel>;
+    onModelLanguageChanged: Event$1<{
         model: ITextModel;
         oldLanguageId: string;
     }>;
@@ -1130,22 +1839,22 @@ interface IEditorService {
      *
      * @see {@link IEditorService.activeEditorPane}
      */
-    readonly onDidActiveEditorChange: Event<void>;
+    readonly onDidActiveEditorChange: Event$1<void>;
     /**
      * Emitted when any of the current visible editors changes.
      *
      * @see {@link IEditorService.visibleEditorPanes}
      */
-    readonly onDidVisibleEditorsChange: Event<void>;
+    readonly onDidVisibleEditorsChange: Event$1<void>;
     /**
      * An aggregated event for any change to any editor across
      * all groups.
      */
-    readonly onDidEditorsChange: Event<IEditorsChangeEvent>;
+    readonly onDidEditorsChange: Event$1<IEditorsChangeEvent>;
     /**
      * Emitted when an editor is closed.
      */
-    readonly onDidCloseEditor: Event<IEditorCloseEvent>;
+    readonly onDidCloseEditor: Event$1<IEditorCloseEvent>;
     /**
      * The currently active editor pane or `undefined` if none. The editor pane is
      * the workbench container for editors of any kind.
@@ -1314,86 +2023,551 @@ interface IEditorService {
     revertAll(options?: IRevertAllEditorsOptions): Promise<boolean>;
 }
 
-declare class DebugCompoundRoot {
-    private stopped;
-    private stopEmitter;
-    onDidSessionStop: Event<void>;
-    sessionStopped(): void;
-}
-
-/**
- * Debug URI format
- *
- * a debug URI represents a Source object and the debug session where the Source comes from.
- *
- *       debug:arbitrary_path?session=123e4567-e89b-12d3-a456-426655440000&ref=1016
- *       \___/ \____________/ \__________________________________________/ \______/
- *         |          |                             |                          |
- *      scheme   source.path                    session id            source.reference
- *
- *
- */
-declare class Source {
-    readonly uri: URI;
-    available: boolean;
-    raw: DebugProtocol.Source;
-    constructor(raw_: DebugProtocol.Source | undefined, sessionId: string, uriIdentityService: IUriIdentityService, logService: ILogService);
-    get name(): string;
-    get origin(): string | undefined;
-    get presentationHint(): "normal" | "emphasize" | "deemphasize" | undefined;
-    get reference(): number | undefined;
-    get inMemory(): boolean;
-    openInEditor(editorService: IEditorService, selection: IRange, preserveFocus?: boolean, sideBySide?: boolean, pinned?: boolean): Promise<IEditorPane | undefined>;
-    static getEncodedDebugData(modelUri: URI): {
-        name: string;
-        path: string;
-        sessionId?: string;
-        sourceReference?: number;
-    };
-}
-
-interface ITaskIdentifier {
-    type: string;
-    [name: string]: any;
+type IconDefaults = ThemeIcon | IconDefinition;
+interface IconDefinition {
+    font?: IconFontContribution;
+    fontCharacter: string;
 }
-
-interface IRawModelUpdate {
-    sessionId: string;
-    threads: DebugProtocol.Thread[];
-    stoppedDetails?: IRawStoppedDetails;
+interface IconContribution {
+    readonly id: string;
+    description: string | undefined;
+    deprecationMessage?: string;
+    readonly defaults: IconDefaults;
 }
-interface IRawStoppedDetails {
-    reason?: string;
-    description?: string;
-    threadId?: number;
-    text?: string;
-    totalFrames?: number;
-    allThreadsStopped?: boolean;
-    framesErrorMessage?: string;
-    hitBreakpointIds?: number[];
+declare namespace IconContribution {
+    function getDefinition(contribution: IconContribution, registry: IIconRegistry): IconDefinition | undefined;
 }
-interface ITreeElement {
-    getId(): string;
+interface IconFontContribution {
+    readonly id: string;
+    readonly definition: IconFontDefinition;
 }
-interface IReplElement extends ITreeElement {
-    toString(includeSource?: boolean): string;
-    readonly sourceData?: IReplElementSource;
+interface IconFontDefinition {
+    readonly weight?: string;
+    readonly style?: string;
+    readonly src: IconFontSource[];
 }
-interface IReplElementSource {
-    readonly source: Source;
-    readonly lineNumber: number;
-    readonly column: number;
+declare namespace IconFontDefinition {
+    function toJSONObject(iconFont: IconFontDefinition): any;
+    function fromJSONObject(json: any): IconFontDefinition | undefined;
 }
-interface IExpressionContainer extends ITreeElement {
-    readonly hasChildren: boolean;
-    evaluateLazy(): Promise<void>;
-    getChildren(): Promise<IExpression[]>;
-    readonly reference?: number;
-    readonly memoryReference?: string;
-    readonly value: string;
-    readonly type?: string;
-    valueChanged?: boolean;
-    readonly presentationHint?: DebugProtocol.VariablePresentationHint | undefined;
+interface IconFontSource {
+    readonly location: URI;
+    readonly format: string;
+}
+interface IIconRegistry {
+    readonly onDidChange: Event$1<void>;
+    /**
+     * Register a icon to the registry.
+     * @param id The icon id
+     * @param defaults The default values
+     * @param description The description
+     */
+    registerIcon(id: IconIdentifier, defaults: IconDefaults, description?: string): ThemeIcon;
+    /**
+     * Deregister a icon from the registry.
+     */
+    deregisterIcon(id: IconIdentifier): void;
+    /**
+     * Get all icon contributions
+     */
+    getIcons(): IconContribution[];
+    /**
+     * Get the icon for the given id
+     */
+    getIcon(id: IconIdentifier): IconContribution | undefined;
+    /**
+     * JSON schema for an object to assign icon values to one of the icon contributions.
+     */
+    getIconSchema(): IJSONSchema;
+    /**
+     * JSON schema to for a reference to a icon contribution.
+     */
+    getIconReferenceSchema(): IJSONSchema;
+    /**
+     * Register a icon font to the registry.
+     * @param id The icon font id
+     * @param definition The icon font definition
+     */
+    registerIconFont(id: string, definition: IconFontDefinition): IconFontDefinition;
+    /**
+     * Deregister an icon font to the registry.
+     */
+    deregisterIconFont(id: string): void;
+    /**
+     * Get the icon font for the given id
+     */
+    getIconFont(id: string): IconFontDefinition | undefined;
+}
+
+/**
+ * Color scheme used by the OS and by color themes.
+ */
+declare enum ColorScheme {
+    DARK = "dark",
+    LIGHT = "light",
+    HIGH_CONTRAST_DARK = "hcDark",
+    HIGH_CONTRAST_LIGHT = "hcLight"
+}
+
+interface ITokenStyle {
+    readonly foreground: number | undefined;
+    readonly bold: boolean | undefined;
+    readonly underline: boolean | undefined;
+    readonly strikethrough: boolean | undefined;
+    readonly italic: boolean | undefined;
+}
+interface IColorTheme {
+    readonly type: ColorScheme;
+    readonly label: string;
+    /**
+     * Resolves the color of the given color identifier. If the theme does not
+     * specify the color, the default color is returned unless <code>useDefault</code> is set to false.
+     * @param color the id of the color
+     * @param useDefault specifies if the default color should be used. If not set, the default is used.
+     */
+    getColor(color: ColorIdentifier, useDefault?: boolean): Color | undefined;
+    /**
+     * Returns whether the theme defines a value for the color. If not, that means the
+     * default color will be used.
+     */
+    defines(color: ColorIdentifier): boolean;
+    /**
+     * Returns the token style for a given classification. The result uses the <code>MetadataConsts</code> format
+     */
+    getTokenStyleMetadata(type: string, modifiers: string[], modelLanguage: string): ITokenStyle | undefined;
+    /**
+     * List of all colors used with tokens. <code>getTokenStyleMetadata</code> references the colors by index into this list.
+     */
+    readonly tokenColorMap: string[];
+    /**
+     * Defines whether semantic highlighting should be enabled for the theme.
+     */
+    readonly semanticHighlighting: boolean;
+}
+interface IFileIconTheme {
+    readonly hasFileIcons: boolean;
+    readonly hasFolderIcons: boolean;
+    readonly hidesExplorerArrows: boolean;
+}
+interface IProductIconTheme {
+    /**
+     * Resolves the definition for the given icon as defined by the theme.
+     *
+     * @param iconContribution The icon
+     */
+    getIcon(iconContribution: IconContribution): IconDefinition | undefined;
+}
+
+declare const IThemeService: ServiceIdentifier<IThemeService>;
+interface IThemeService {
+    readonly _serviceBrand: undefined;
+    getColorTheme(): IColorTheme;
+    readonly onDidColorThemeChange: Event$1<IColorTheme>;
+    getFileIconTheme(): IFileIconTheme;
+    readonly onDidFileIconThemeChange: Event$1<IFileIconTheme>;
+    getProductIconTheme(): IProductIconTheme;
+    readonly onDidProductIconThemeChange: Event$1<IProductIconTheme>;
+}
+/**
+ * Utility base class for all themable components.
+ */
+declare class Themable extends Disposable {
+    protected themeService: IThemeService;
+    protected theme: IColorTheme;
+    constructor(themeService: IThemeService);
+    protected onThemeChange(theme: IColorTheme): void;
+    updateStyles(): void;
+    protected getColor(id: string, modify?: (color: Color, theme: IColorTheme) => Color): string | null;
+}
+
+interface IBaseOpenWindowsOptions {
+    /**
+     * Whether to reuse the window or open a new one.
+     */
+    readonly forceReuseWindow?: boolean;
+    /**
+     * The remote authority to use when windows are opened with either
+     * - no workspace (empty window)
+     * - a workspace that is neither `file://` nor `vscode-remote://`
+     * Use 'null' for a local window.
+     * If not set, defaults to the remote authority of the current window.
+     */
+    readonly remoteAuthority?: string | null;
+}
+interface IOpenWindowOptions extends IBaseOpenWindowsOptions {
+    readonly forceNewWindow?: boolean;
+    readonly preferNewWindow?: boolean;
+    readonly noRecentEntry?: boolean;
+    readonly addMode?: boolean;
+    readonly diffMode?: boolean;
+    readonly mergeMode?: boolean;
+    readonly gotoLineMode?: boolean;
+    readonly waitMarkerFileURI?: URI;
+    readonly forceProfile?: string;
+    readonly forceTempProfile?: boolean;
+}
+interface IOpenEmptyWindowOptions extends IBaseOpenWindowsOptions {
+}
+type IWindowOpenable = IWorkspaceToOpen | IFolderToOpen | IFileToOpen;
+interface IBaseWindowOpenable {
+    label?: string;
+}
+interface IWorkspaceToOpen extends IBaseWindowOpenable {
+    readonly workspaceUri: URI;
+}
+interface IFolderToOpen extends IBaseWindowOpenable {
+    readonly folderUri: URI;
+}
+interface IFileToOpen extends IBaseWindowOpenable {
+    readonly fileUri: URI;
+}
+interface IPath$1<T = IEditorOptions> extends IPathData<T> {
+    /**
+     * The file path to open within the instance
+     */
+    fileUri?: URI;
+}
+interface IPathData<T = IEditorOptions> {
+    /**
+     * The file path to open within the instance
+     */
+    readonly fileUri?: UriComponents;
+    /**
+     * Optional editor options to apply in the file
+     */
+    readonly options?: T;
+    /**
+     * A hint that the file exists. if true, the
+     * file exists, if false it does not. with
+     * `undefined` the state is unknown.
+     */
+    readonly exists?: boolean;
+    /**
+     * A hint about the file type of this path.
+     * with `undefined` the type is unknown.
+     */
+    readonly type?: FileType;
+    /**
+     * Specifies if the file should be only be opened
+     * if it exists.
+     */
+    readonly openOnlyIfExists?: boolean;
+}
+
+declare abstract class AbstractSettingsModel extends EditorModel {
+    protected _currentResultGroups: Map<string, ISearchResultGroup>;
+    updateResultGroup(id: string, resultGroup: ISearchResultGroup | undefined): IFilterResult | undefined;
+    /**
+     * Remove duplicates between result groups, preferring results in earlier groups
+     */
+    private removeDuplicateResults;
+    private compareTwoNullableNumbers;
+    filterSettings(filter: string, groupFilter: IGroupFilter, settingMatcher: ISettingMatcher): ISettingMatch[];
+    getPreference(key: string): ISetting | undefined;
+    protected collectMetadata(groups: ISearchResultGroup[]): IStringDictionary<IFilterMetadata>;
+    protected get filterGroups(): ISettingsGroup[];
+    abstract settingsGroups: ISettingsGroup[];
+    abstract findValueMatches(filter: string, setting: ISetting): IRange[];
+    protected abstract update(): IFilterResult | undefined;
+}
+declare class Settings2EditorModel extends AbstractSettingsModel implements ISettingsEditorModel {
+    private _defaultSettings;
+    private readonly _onDidChangeGroups;
+    readonly onDidChangeGroups: Event$1<void>;
+    private additionalGroups;
+    private dirty;
+    constructor(_defaultSettings: DefaultSettings, configurationService: IConfigurationService);
+    /** Doesn't include the "Commonly Used" group */
+    protected get filterGroups(): ISettingsGroup[];
+    get settingsGroups(): ISettingsGroup[];
+    /** For programmatically added groups outside of registered configurations */
+    setAdditionalGroups(groups: ISettingsGroup[]): void;
+    findValueMatches(filter: string, setting: ISetting): IRange[];
+    protected update(): IFilterResult;
+}
+declare class DefaultSettings extends Disposable {
+    private _mostCommonlyUsedSettingsKeys;
+    readonly target: ConfigurationTarget;
+    private _allSettingsGroups;
+    private _content;
+    private _contentWithoutMostCommonlyUsed;
+    private _settingsByName;
+    readonly _onDidChange: Emitter<void>;
+    readonly onDidChange: Event$1<void>;
+    constructor(_mostCommonlyUsedSettingsKeys: string[], target: ConfigurationTarget);
+    getContent(forceUpdate?: boolean): string;
+    getContentWithoutMostCommonlyUsed(forceUpdate?: boolean): string;
+    getSettingsGroups(forceUpdate?: boolean): ISettingsGroup[];
+    private initialize;
+    private parse;
+    getRegisteredGroups(): ISettingsGroup[];
+    private sortGroups;
+    private initAllSettingsMap;
+    private getMostCommonlyUsedSettings;
+    private parseConfig;
+    private removeEmptySettingsGroups;
+    private parseSettings;
+    private parseOverrideSettings;
+    private matchesScope;
+    private compareConfigurationNodes;
+    private toContent;
+}
+
+interface ISettingsGroup {
+    id: string;
+    range: IRange;
+    title: string;
+    titleRange: IRange;
+    sections: ISettingsSection[];
+    order?: number;
+    extensionInfo?: IExtensionInfo;
+}
+interface ISettingsSection {
+    titleRange?: IRange;
+    title?: string;
+    settings: ISetting[];
+}
+interface ISetting {
+    range: IRange;
+    key: string;
+    keyRange: IRange;
+    value: any;
+    valueRange: IRange;
+    description: string[];
+    descriptionIsMarkdown?: boolean;
+    descriptionRanges: IRange[];
+    overrides?: ISetting[];
+    overrideOf?: ISetting;
+    deprecationMessage?: string;
+    deprecationMessageIsMarkdown?: boolean;
+    scope?: ConfigurationScope;
+    type?: string | string[];
+    order?: number;
+    arrayItemType?: string;
+    objectProperties?: IJSONSchemaMap;
+    objectPatternProperties?: IJSONSchemaMap;
+    objectAdditionalProperties?: boolean | IJSONSchema;
+    enum?: string[];
+    enumDescriptions?: string[];
+    enumDescriptionsAreMarkdown?: boolean;
+    uniqueItems?: boolean;
+    tags?: string[];
+    disallowSyncIgnore?: boolean;
+    restricted?: boolean;
+    extensionInfo?: IExtensionInfo;
+    validator?: (value: any) => string | null;
+    enumItemLabels?: string[];
+    allKeysAreBoolean?: boolean;
+    editPresentation?: EditPresentationTypes;
+    nonLanguageSpecificDefaultValueSource?: string | IExtensionInfo;
+    isLanguageTagSetting?: boolean;
+    categoryOrder?: number;
+    categoryLabel?: string;
+    displayExtensionId?: string;
+    stableExtensionId?: string;
+    prereleaseExtensionId?: string;
+    title?: string;
+    extensionGroupTitle?: string;
+}
+interface ISearchResult {
+    filterMatches: ISettingMatch[];
+    exactMatch?: boolean;
+    metadata?: IFilterMetadata;
+}
+interface ISearchResultGroup {
+    id: string;
+    label: string;
+    result: ISearchResult;
+    order: number;
+}
+interface IFilterResult {
+    query?: string;
+    filteredGroups: ISettingsGroup[];
+    allGroups: ISettingsGroup[];
+    matches: IRange[];
+    metadata?: IStringDictionary<IFilterMetadata>;
+    exactMatch?: boolean;
+}
+/**
+ * The ways a setting could match a query,
+ * sorted in increasing order of relevance.
+ * For now, ignore description and value matches.
+ */
+declare enum SettingMatchType {
+    None = 0,
+    WholeWordMatch = 1,
+    KeyMatch = 2
+}
+interface ISettingMatch {
+    setting: ISetting;
+    matches: IRange[] | null;
+    matchType: SettingMatchType;
+    score: number;
+}
+interface IScoredResults {
+    [key: string]: IRemoteSetting;
+}
+interface IRemoteSetting {
+    score: number;
+    key: string;
+    id: string;
+    defaultValue: string;
+    description: string;
+    packageId: string;
+    extensionName?: string;
+    extensionPublisher?: string;
+}
+interface IFilterMetadata {
+    requestUrl: string;
+    requestBody: string;
+    timestamp: number;
+    duration: number;
+    scoredResults: IScoredResults;
+    /** The number of requests made, since requests are split by number of filters */
+    requestCount?: number;
+    /** The name of the server that actually served the request */
+    context: string;
+}
+interface IPreferencesEditorModel<T> {
+    uri?: URI;
+    getPreference(key: string): T | undefined;
+    dispose(): void;
+}
+type IGroupFilter = (group: ISettingsGroup) => boolean | null;
+type ISettingMatcher = (setting: ISetting, group: ISettingsGroup) => {
+    matches: IRange[];
+    matchType: SettingMatchType;
+    score: number;
+} | null;
+interface ISettingsEditorModel extends IPreferencesEditorModel<ISetting> {
+    readonly onDidChangeGroups: Event$1<void>;
+    settingsGroups: ISettingsGroup[];
+    filterSettings(filter: string, groupFilter: IGroupFilter, settingMatcher: ISettingMatcher): ISettingMatch[];
+    findValueMatches(filter: string, setting: ISetting): IRange[];
+    updateResultGroup(id: string, resultGroup: ISearchResultGroup | undefined): IFilterResult | undefined;
+}
+interface ISettingsEditorOptions extends IEditorOptions {
+    target?: ConfigurationTarget;
+    folderUri?: URI;
+    query?: string;
+    revealSetting?: {
+        key: string;
+        edit?: boolean;
+    };
+    focusSearch?: boolean;
+}
+interface IOpenSettingsOptions extends ISettingsEditorOptions {
+    jsonEditor?: boolean;
+    openToSide?: boolean;
+}
+interface IKeybindingsEditorOptions extends IEditorOptions {
+    query?: string;
+}
+declare const IPreferencesService: ServiceIdentifier<IPreferencesService>;
+interface IPreferencesService {
+    readonly _serviceBrand: undefined;
+    userSettingsResource: URI;
+    workspaceSettingsResource: URI | null;
+    getFolderSettingsResource(resource: URI): URI | null;
+    createPreferencesEditorModel(uri: URI): Promise<IPreferencesEditorModel<ISetting> | null>;
+    resolveModel(uri: URI): ITextModel | null;
+    createSettings2EditorModel(): Settings2EditorModel;
+    openRawDefaultSettings(): Promise<IEditorPane | undefined>;
+    openSettings(options?: IOpenSettingsOptions): Promise<IEditorPane | undefined>;
+    openApplicationSettings(options?: IOpenSettingsOptions): Promise<IEditorPane | undefined>;
+    openUserSettings(options?: IOpenSettingsOptions): Promise<IEditorPane | undefined>;
+    openRemoteSettings(options?: IOpenSettingsOptions): Promise<IEditorPane | undefined>;
+    openWorkspaceSettings(options?: IOpenSettingsOptions): Promise<IEditorPane | undefined>;
+    openFolderSettings(options: IOpenSettingsOptions & {
+        folderUri: IOpenSettingsOptions['folderUri'];
+    }): Promise<IEditorPane | undefined>;
+    openGlobalKeybindingSettings(textual: boolean, options?: IKeybindingsEditorOptions): Promise<void>;
+    openDefaultKeybindingsFile(): Promise<IEditorPane | undefined>;
+    openLanguageSpecificSettings(languageId: string, options?: IOpenSettingsOptions): Promise<IEditorPane | undefined>;
+    getEditableSettingsURI(configurationTarget: ConfigurationTarget, resource?: URI): Promise<URI | null>;
+    createSplitJsonEditorInput(configurationTarget: ConfigurationTarget, resource: URI): EditorInput;
+}
+
+declare class DebugCompoundRoot {
+    private stopped;
+    private stopEmitter;
+    onDidSessionStop: Event$1<void>;
+    sessionStopped(): void;
+}
+
+/**
+ * Debug URI format
+ *
+ * a debug URI represents a Source object and the debug session where the Source comes from.
+ *
+ *       debug:arbitrary_path?session=123e4567-e89b-12d3-a456-426655440000&ref=1016
+ *       \___/ \____________/ \__________________________________________/ \______/
+ *         |          |                             |                          |
+ *      scheme   source.path                    session id            source.reference
+ *
+ *
+ */
+declare class Source {
+    readonly uri: URI;
+    available: boolean;
+    raw: DebugProtocol.Source;
+    constructor(raw_: DebugProtocol.Source | undefined, sessionId: string, uriIdentityService: IUriIdentityService, logService: ILogService);
+    get name(): string;
+    get origin(): string | undefined;
+    get presentationHint(): "normal" | "emphasize" | "deemphasize" | undefined;
+    get reference(): number | undefined;
+    get inMemory(): boolean;
+    openInEditor(editorService: IEditorService, selection: IRange, preserveFocus?: boolean, sideBySide?: boolean, pinned?: boolean): Promise<IEditorPane | undefined>;
+    static getEncodedDebugData(modelUri: URI): {
+        name: string;
+        path: string;
+        sessionId?: string;
+        sourceReference?: number;
+    };
+}
+
+interface ITaskIdentifier {
+    type: string;
+    [name: string]: any;
+}
+
+interface IRawModelUpdate {
+    sessionId: string;
+    threads: DebugProtocol.Thread[];
+    stoppedDetails?: IRawStoppedDetails;
+}
+interface IRawStoppedDetails {
+    reason?: string;
+    description?: string;
+    threadId?: number;
+    text?: string;
+    totalFrames?: number;
+    allThreadsStopped?: boolean;
+    framesErrorMessage?: string;
+    hitBreakpointIds?: number[];
+}
+interface ITreeElement {
+    getId(): string;
+}
+interface IReplElement extends ITreeElement {
+    toString(includeSource?: boolean): string;
+    readonly sourceData?: IReplElementSource;
+}
+interface IReplElementSource {
+    readonly source: Source;
+    readonly lineNumber: number;
+    readonly column: number;
+}
+interface IExpressionContainer extends ITreeElement {
+    readonly hasChildren: boolean;
+    evaluateLazy(): Promise<void>;
+    getChildren(): Promise<IExpression[]>;
+    readonly reference?: number;
+    readonly memoryReference?: string;
+    readonly value: string;
+    readonly type?: string;
+    valueChanged?: boolean;
+    readonly presentationHint?: DebugProtocol.VariablePresentationHint | undefined;
 }
 interface IExpression extends IExpressionContainer {
     name: string;
@@ -1491,7 +2665,7 @@ interface IMemoryRegion extends IDisposable {
      * Event that fires when memory changes. Can be a result of memory events or
      * `write` requests.
      */
-    readonly onDidInvalidate: Event<IMemoryInvalidationEvent>;
+    readonly onDidInvalidate: Event$1<IMemoryInvalidationEvent>;
     /**
      * Whether writes are supported on this memory region.
      */
@@ -1546,7 +2720,7 @@ interface IDebugSession extends ITreeElement {
     setSubId(subId: string | undefined): void;
     getMemory(memoryReference: string): IMemoryRegion;
     setName(name: string): void;
-    readonly onDidChangeName: Event<string>;
+    readonly onDidChangeName: Event$1<string>;
     getLabel(): string;
     getSourceForUri(modelUri: URI): Source | undefined;
     getSource(raw?: DebugProtocol.Source): Source;
@@ -1564,16 +2738,16 @@ interface IDebugSession extends ITreeElement {
     removeReplExpressions(): void;
     addReplExpression(stackFrame: IStackFrame | undefined, name: string): Promise<void>;
     appendToRepl(data: INewReplElementData): void;
-    readonly onDidEndAdapter: Event<AdapterEndEvent | undefined>;
-    readonly onDidChangeState: Event<void>;
-    readonly onDidChangeReplElements: Event<void>;
+    readonly onDidEndAdapter: Event$1<AdapterEndEvent | undefined>;
+    readonly onDidChangeState: Event$1<void>;
+    readonly onDidChangeReplElements: Event$1<void>;
     readonly capabilities: DebugProtocol.Capabilities;
-    readonly onDidLoadedSource: Event<LoadedSourceEvent>;
-    readonly onDidCustomEvent: Event<DebugProtocol.Event>;
-    readonly onDidProgressStart: Event<DebugProtocol.ProgressStartEvent>;
-    readonly onDidProgressUpdate: Event<DebugProtocol.ProgressUpdateEvent>;
-    readonly onDidProgressEnd: Event<DebugProtocol.ProgressEndEvent>;
-    readonly onDidInvalidateMemory: Event<DebugProtocol.MemoryEvent>;
+    readonly onDidLoadedSource: Event$1<LoadedSourceEvent>;
+    readonly onDidCustomEvent: Event$1<DebugProtocol.Event>;
+    readonly onDidProgressStart: Event$1<DebugProtocol.ProgressStartEvent>;
+    readonly onDidProgressUpdate: Event$1<DebugProtocol.ProgressUpdateEvent>;
+    readonly onDidProgressEnd: Event$1<DebugProtocol.ProgressEndEvent>;
+    readonly onDidInvalidateMemory: Event$1<DebugProtocol.MemoryEvent>;
     initialize(dbgr: IDebugger): Promise<void>;
     launchOrAttach(config: IConfig): Promise<void>;
     restart(): Promise<void>;
@@ -1607,7 +2781,7 @@ interface IDebugSession extends ITreeElement {
     reverseContinue(threadId: number): Promise<void>;
     pause(threadId: number): Promise<void>;
     terminateThreads(threadIds: number[]): Promise<void>;
-    completions(frameId: number | undefined, threadId: number, text: string, position: Position, overwriteBefore: number, token: CancellationToken): Promise<DebugProtocol.CompletionsResponse | undefined>;
+    completions(frameId: number | undefined, threadId: number, text: string, position: Position$1, overwriteBefore: number, token: CancellationToken): Promise<DebugProtocol.CompletionsResponse | undefined>;
     setVariable(variablesReference: number | undefined, name: string, value: string): Promise<DebugProtocol.SetVariableResponse | undefined>;
     setExpression(frameId: number, expression: string, value: string): Promise<DebugProtocol.SetExpressionResponse | undefined>;
     loadSource(resource: URI): Promise<DebugProtocol.SourceResponse | undefined>;
@@ -1775,23 +2949,23 @@ interface IViewModel extends ITreeElement {
     setSelectedExpression(expression: IExpression | undefined, settingWatch: boolean): void;
     updateViews(): void;
     isMultiSessionView(): boolean;
-    onDidFocusSession: Event<IDebugSession | undefined>;
-    onDidFocusThread: Event<{
+    onDidFocusSession: Event$1<IDebugSession | undefined>;
+    onDidFocusThread: Event$1<{
         thread: IThread | undefined;
         explicit: boolean;
         session: IDebugSession | undefined;
     }>;
-    onDidFocusStackFrame: Event<{
+    onDidFocusStackFrame: Event$1<{
         stackFrame: IStackFrame | undefined;
         explicit: boolean;
         session: IDebugSession | undefined;
     }>;
-    onDidSelectExpression: Event<{
+    onDidSelectExpression: Event$1<{
         expression: IExpression;
         settingWatch: boolean;
     } | undefined>;
-    onDidEvaluateLazyExpression: Event<IExpressionContainer>;
-    onWillUpdateViews: Event<void>;
+    onDidEvaluateLazyExpression: Event$1<IExpressionContainer>;
+    onWillUpdateViews: Event$1<void>;
     evaluateLazyExpression(expression: IExpressionContainer): void;
 }
 interface IEvaluate {
@@ -1821,9 +2995,9 @@ interface IDebugModel extends ITreeElement {
     getExceptionBreakpointsForSession(sessionId?: string): ReadonlyArray<IExceptionBreakpoint>;
     getInstructionBreakpoints(): ReadonlyArray<IInstructionBreakpoint>;
     getWatchExpressions(): ReadonlyArray<IExpression & IEvaluate>;
-    onDidChangeBreakpoints: Event<IBreakpointsChangeEvent | undefined>;
-    onDidChangeCallStack: Event<void>;
-    onDidChangeWatchExpressions: Event<IExpression | undefined>;
+    onDidChangeBreakpoints: Event$1<IBreakpointsChangeEvent | undefined>;
+    onDidChangeCallStack: Event$1<void>;
+    onDidChangeWatchExpressions: Event$1<IExpression | undefined>;
     fetchCallstack(thread: IThread, levels?: number): Promise<void>;
 }
 /**
@@ -1875,8 +3049,8 @@ interface ICompound {
     presentation?: IConfigPresentation;
 }
 interface IDebugAdapter extends IDisposable {
-    readonly onError: Event<Error>;
-    readonly onExit: Event<number | null>;
+    readonly onError: Event$1<Error>;
+    readonly onExit: Event$1<number | null>;
     onRequest(callback: (request: DebugProtocol.Request) => void): void;
     onEvent(callback: (event: DebugProtocol.Event) => void): void;
     startSession(): Promise<void>;
@@ -1911,7 +3085,7 @@ interface IDebugAdapterNamedPipeServer {
     readonly path: string;
 }
 interface IDebugAdapterInlineImpl extends IDisposable {
-    readonly onDidSendMessage: Event<DebugProtocol.Message>;
+    readonly onDidSendMessage: Event$1<DebugProtocol.Message>;
     handleMessage(message: DebugProtocol.Message): void;
 }
 interface IDebugAdapterImpl {
@@ -1971,7 +3145,7 @@ interface IConfigurationManager {
     /**
      * Allows to register on change of selected debug configuration.
      */
-    onDidSelectConfiguration: Event<void>;
+    onDidSelectConfiguration: Event$1<void>;
     hasDebugConfigurationProvider(debugType: string): boolean;
     getDynamicProviders(): Promise<{
         label: string;
@@ -1989,7 +3163,7 @@ declare enum DebuggerString {
     UnverifiedBreakpoints = "unverifiedBreakpoints"
 }
 interface IAdapterManager {
-    onDidRegisterDebugger: Event<void>;
+    onDidRegisterDebugger: Event$1<void>;
     hasEnabledDebuggers(): boolean;
     getDebugAdapterDescriptor(session: IDebugSession): Promise<IAdapterDescriptor | undefined>;
     getDebuggerLabel(type: string): string | undefined;
@@ -2004,7 +3178,7 @@ interface IAdapterManager {
     runInTerminal(debugType: string, args: DebugProtocol.RunInTerminalRequestArguments, sessionId: string): Promise<number | undefined>;
     getEnabledDebugger(type: string): (IDebugger & IDebuggerMetadata) | undefined;
     guessDebugger(gettingConfigurations: boolean): Promise<(IDebugger & IDebuggerMetadata) | undefined>;
-    get onDidDebuggersExtPointRead(): Event<void>;
+    get onDidDebuggersExtPointRead(): Event$1<void>;
 }
 interface ILaunch {
     /**
@@ -2061,19 +3235,19 @@ interface IDebugService {
     /**
      * Allows to register on debug state changes.
      */
-    onDidChangeState: Event<State>;
+    onDidChangeState: Event$1<State>;
     /**
      * Allows to register on new session events.
      */
-    onDidNewSession: Event<IDebugSession>;
+    onDidNewSession: Event$1<IDebugSession>;
     /**
      * Allows to register on sessions about to be created (not yet fully initialised)
      */
-    onWillNewSession: Event<IDebugSession>;
+    onWillNewSession: Event$1<IDebugSession>;
     /**
      * Allows to register on end session events.
      */
-    onDidEndSession: Event<IDebugSession>;
+    onDidEndSession: Event$1<IDebugSession>;
     /**
      * Gets the configuration manager.
      */
@@ -2228,11 +3402,36 @@ interface ILanguageStatus {
 declare const ILanguageStatusService: ServiceIdentifier<ILanguageStatusService>;
 interface ILanguageStatusService {
     _serviceBrand: undefined;
-    onDidChange: Event<void>;
+    onDidChange: Event$1<void>;
     addStatus(status: ILanguageStatus): IDisposable;
     getLanguageStatus(model: ITextModel): ILanguageStatus[];
 }
 
+declare const IWorkbenchEnvironmentService: ServiceIdentifier<IWorkbenchEnvironmentService>;
+/**
+ * A workbench specific environment service that is only present in workbench
+ * layer.
+ */
+interface IWorkbenchEnvironmentService extends IEnvironmentService {
+    readonly logFile: URI;
+    readonly windowLogsPath: URI;
+    readonly extHostLogsPath: URI;
+    readonly extHostTelemetryLogFile: URI;
+    readonly extensionEnabledProposedApi?: string[];
+    readonly remoteAuthority?: string;
+    readonly skipReleaseNotes: boolean;
+    readonly skipWelcome: boolean;
+    readonly disableWorkspaceTrust: boolean;
+    readonly webviewExternalEndpoint: string;
+    readonly debugRenderer: boolean;
+    readonly logExtensionHostCommunication?: boolean;
+    readonly enableSmokeTestDriver?: boolean;
+    readonly profDurationMarkers?: string[];
+    readonly filesToOpenOrCreate?: IPath$1[] | undefined;
+    readonly filesToDiff?: IPath$1[] | undefined;
+    readonly filesToMerge?: IPath$1[] | undefined;
+}
+
 interface ParsedPath {
     root: string;
     dir: string;
@@ -2317,6 +3516,100 @@ interface IPathService {
     readonly resolvedUserHome: URI | undefined;
 }
 
+type OpenInternalOptions = {
+    /**
+     * Signals that the intent is to open an editor to the side
+     * of the currently active editor.
+     */
+    readonly openToSide?: boolean;
+    /**
+     * Extra editor options to apply in case an editor is used to open.
+     */
+    readonly editorOptions?: IEditorOptions;
+    /**
+     * Signals that the editor to open was triggered through a user
+     * action, such as keyboard or mouse usage.
+     */
+    readonly fromUserGesture?: boolean;
+    /**
+     * Allow command links to be handled.
+     *
+     * If this is an array, then only the commands included in the array can be run.
+     */
+    readonly allowCommands?: boolean | readonly string[];
+};
+type OpenExternalOptions = {
+    readonly openExternal?: boolean;
+    readonly allowTunneling?: boolean;
+    readonly allowContributedOpeners?: boolean | string;
+    readonly fromWorkspace?: boolean;
+};
+type OpenOptions = OpenInternalOptions & OpenExternalOptions;
+type ResolveExternalUriOptions = {
+    readonly allowTunneling?: boolean;
+};
+interface IResolvedExternalUri extends IDisposable {
+    resolved: URI;
+}
+interface IOpener {
+    open(resource: URI | string, options?: OpenInternalOptions | OpenExternalOptions): Promise<boolean>;
+}
+interface IExternalOpener {
+    openExternal(href: string, ctx: {
+        sourceUri: URI;
+        preferredOpenerId?: string;
+    }, token: CancellationToken): Promise<boolean>;
+    dispose?(): void;
+}
+interface IValidator {
+    shouldOpen(resource: URI | string, openOptions?: OpenOptions): Promise<boolean>;
+}
+interface IExternalUriResolver {
+    resolveExternalUri(resource: URI, options?: OpenOptions): Promise<{
+        resolved: URI;
+        dispose(): void;
+    } | undefined>;
+}
+
+declare const IOpenerService: ServiceIdentifier<IOpenerService>;
+interface IOpenerService {
+    readonly _serviceBrand: undefined;
+    /**
+     * Register a participant that can handle the open() call.
+     */
+    registerOpener(opener: IOpener): IDisposable;
+    /**
+     * Register a participant that can validate if the URI resource be opened.
+     * Validators are run before openers.
+     */
+    registerValidator(validator: IValidator): IDisposable;
+    /**
+     * Register a participant that can resolve an external URI resource to be opened.
+     */
+    registerExternalUriResolver(resolver: IExternalUriResolver): IDisposable;
+    /**
+     * Sets the handler for opening externally. If not provided,
+     * a default handler will be used.
+     */
+    setDefaultExternalOpener(opener: IExternalOpener): void;
+    /**
+     * Registers a new opener external resources openers.
+     */
+    registerExternalOpener(opener: IExternalOpener): IDisposable;
+    /**
+     * Opens a resource, like a webaddress, a document uri, or executes command.
+     *
+     * @param resource A resource
+     * @return A promise that resolves when the opening is done.
+     */
+    open(resource: URI | string, options?: OpenInternalOptions | OpenExternalOptions): Promise<boolean>;
+    /**
+     * Resolve a resource to its external form.
+     * @throws whenever resolvers couldn't resolve this resource externally.
+     */
+    resolveExternalUri(resource: URI, options?: ResolveExternalUriOptions): Promise<IResolvedExternalUri>;
+}
+
 declare const IHostService: ServiceIdentifier<IHostService>;
 /**
  * A set of methods supported in both web and native environments.
@@ -2329,7 +3622,7 @@ interface IHostService {
     /**
      * Emitted when the window focus changes.
      */
-    readonly onDidChangeFocus: Event<boolean>;
+    readonly onDidChangeFocus: Event$1<boolean>;
     /**
      * Find out if the window has focus or not.
      */
@@ -2417,6 +3710,45 @@ interface IUnicodeHighlightsResult {
     ambiguousCharacterCount: number;
 }
 
+interface IKeyboardEvent {
+    readonly _standardKeyboardEventBrand: true;
+    readonly browserEvent: KeyboardEvent;
+    readonly target: HTMLElement;
+    readonly ctrlKey: boolean;
+    readonly shiftKey: boolean;
+    readonly altKey: boolean;
+    readonly metaKey: boolean;
+    readonly altGraphKey: boolean;
+    readonly keyCode: KeyCode;
+    readonly code: string;
+    /**
+     * @internal
+     */
+    toKeyCodeChord(): KeyCodeChord;
+    equals(keybinding: number): boolean;
+    preventDefault(): void;
+    stopPropagation(): void;
+}
+
+interface IMouseEvent {
+    readonly browserEvent: MouseEvent;
+    readonly leftButton: boolean;
+    readonly middleButton: boolean;
+    readonly rightButton: boolean;
+    readonly buttons: number;
+    readonly target: HTMLElement;
+    readonly detail: number;
+    readonly posx: number;
+    readonly posy: number;
+    readonly ctrlKey: boolean;
+    readonly shiftKey: boolean;
+    readonly altKey: boolean;
+    readonly metaKey: boolean;
+    readonly timestamp: number;
+    preventDefault(): void;
+    stopPropagation(): void;
+}
+
 declare class ResourceEdit {
     readonly metadata?: WorkspaceEditMetadata | undefined;
     protected constructor(metadata?: WorkspaceEditMetadata | undefined);
@@ -2482,47 +3814,1307 @@ interface IClipboardService {
     hasResources(): Promise<boolean>;
 }
 
-declare const IPaneCompositePartService: ServiceIdentifier<IPaneCompositePartService>;
-interface IPaneCompositePartService {
-    readonly _serviceBrand: undefined;
-    readonly onDidPaneCompositeOpen: Event<{
-        composite: IPaneComposite;
-        viewContainerLocation: ViewContainerLocation;
-    }>;
-    readonly onDidPaneCompositeClose: Event<{
-        composite: IPaneComposite;
-        viewContainerLocation: ViewContainerLocation;
-    }>;
+interface IDimension {
+    readonly width: number;
+    readonly height: number;
+}
+declare class Dimension implements IDimension {
+    readonly width: number;
+    readonly height: number;
+    static readonly None: Dimension;
+    constructor(width: number, height: number);
+    with(width?: number, height?: number): Dimension;
+    static is(obj: unknown): obj is IDimension;
+    static lift(obj: IDimension): Dimension;
+    static equals(a: Dimension | undefined, b: Dimension | undefined): boolean;
+}
+interface IDomPosition {
+    readonly left: number;
+    readonly top: number;
+}
+
+interface ILayoutOffsetInfo {
     /**
-     * Opens a viewlet with the given identifier and pass keyboard focus to it if specified.
+     * Generic top offset
      */
-    openPaneComposite(id: string | undefined, viewContainerLocation: ViewContainerLocation, focus?: boolean): Promise<IPaneComposite | undefined>;
+    readonly top: number;
     /**
-     * Returns the current active viewlet if any.
+     * Quick pick specific top offset.
      */
-    getActivePaneComposite(viewContainerLocation: ViewContainerLocation): IPaneComposite | undefined;
+    readonly quickPickTop: number;
+}
+
+declare const ILayoutService: ServiceIdentifier<ILayoutService>;
+interface ILayoutService {
+    readonly _serviceBrand: undefined;
     /**
-     * Returns the viewlet by id.
+     * The dimensions of the container.
      */
-    getPaneComposite(id: string, viewContainerLocation: ViewContainerLocation): PaneCompositeDescriptor | undefined;
+    readonly dimension: IDimension;
     /**
-     * Returns all enabled viewlets
+     * Does the application have a single container?
      */
-    getPaneComposites(viewContainerLocation: ViewContainerLocation): PaneCompositeDescriptor[];
+    readonly hasContainer: boolean;
     /**
-     * Returns id of pinned view containers following the visual order.
+     * Container of the application.
+     *
+     * **NOTE**: In the standalone editor case, multiple editors can be created on a page.
+     * Therefore, in the standalone editor case, there are multiple containers, not just
+     * a single one. If you ship code that needs a "container" for the standalone editor,
+     * please use `ICodeEditorService` to get the current focused code editor and use its
+     * container if necessary. You can also instantiate `EditorScopedLayoutService`
+     * which implements `ILayoutService` but is not a part of the service collection because
+     * it is code editor instance specific.
+     *
      */
-    getPinnedPaneCompositeIds(viewContainerLocation: ViewContainerLocation): string[];
+    readonly container: HTMLElement;
     /**
-     * Returns id of visible view containers following the visual order.
+     * An offset to use for positioning elements inside the container.
      */
-    getVisiblePaneCompositeIds(viewContainerLocation: ViewContainerLocation): string[];
+    readonly offset: ILayoutOffsetInfo;
     /**
-     * Returns the progress indicator for the side bar.
+     * An event that is emitted when the container is layed out. The
+     * event carries the dimensions of the container as part of it.
      */
-    getProgressIndicator(id: string, viewContainerLocation: ViewContainerLocation): IProgressIndicator | undefined;
+    readonly onDidLayout: Event$1<IDimension>;
     /**
-     * Hide the active viewlet.
+     * Focus the primary component of the container.
+     */
+    focus(): void;
+}
+
+type MementoObject = {
+    [key: string]: any;
+};
+
+declare class Component extends Themable {
+    private readonly id;
+    private readonly memento;
+    constructor(id: string, themeService: IThemeService, storageService: IStorageService);
+    getId(): string;
+    protected getMemento(scope: StorageScope, target: StorageTarget): MementoObject;
+    protected saveState(): void;
+}
+
+declare const enum LayoutPriority {
+    Normal = 0,
+    Low = 1,
+    High = 2
+}
+/**
+ * The interface to implement for views within a {@link SplitView}.
+ *
+ * An optional {@link TLayoutContext layout context type} may be used in order to
+ * pass along layout contextual data from the {@link SplitView.layout} method down
+ * to each view's {@link IView.layout} calls.
+ */
+interface IView$2<TLayoutContext = undefined> {
+    /**
+     * The DOM element for this view.
+     */
+    readonly element: HTMLElement;
+    /**
+     * A minimum size for this view.
+     *
+     * @remarks If none, set it to `0`.
+     */
+    readonly minimumSize: number;
+    /**
+     * A maximum size for this view.
+     *
+     * @remarks If none, set it to `Number.POSITIVE_INFINITY`.
+     */
+    readonly maximumSize: number;
+    /**
+     * The priority of the view when the {@link SplitView.resize layout} algorithm
+     * runs. Views with higher priority will be resized first.
+     *
+     * @remarks Only used when `proportionalLayout` is false.
+     */
+    readonly priority?: LayoutPriority;
+    /**
+     * If the {@link SplitView} supports {@link ISplitViewOptions.proportionalLayout proportional layout},
+     * this property allows for finer control over the proportional layout algorithm, per view.
+     *
+     * @defaultValue `true`
+     */
+    readonly proportionalLayout?: boolean;
+    /**
+     * Whether the view will snap whenever the user reaches its minimum size or
+     * attempts to grow it beyond the minimum size.
+     *
+     * @defaultValue `false`
+     */
+    readonly snap?: boolean;
+    /**
+     * View instances are supposed to fire the {@link IView.onDidChange} event whenever
+     * any of the constraint properties have changed:
+     *
+     * - {@link IView.minimumSize}
+     * - {@link IView.maximumSize}
+     * - {@link IView.priority}
+     * - {@link IView.snap}
+     *
+     * The SplitView will relayout whenever that happens. The event can optionally emit
+     * the view's preferred size for that relayout.
+     */
+    readonly onDidChange: Event$1<number | undefined>;
+    /**
+     * This will be called by the {@link SplitView} during layout. A view meant to
+     * pass along the layout information down to its descendants.
+     *
+     * @param size The size of this view, in pixels.
+     * @param offset The offset of this view, relative to the start of the {@link SplitView}.
+     * @param context The optional {@link IView layout context} passed to {@link SplitView.layout}.
+     */
+    layout(size: number, offset: number, context: TLayoutContext | undefined): void;
+    /**
+     * This will be called by the {@link SplitView} whenever this view is made
+     * visible or hidden.
+     *
+     * @param visible Whether the view becomes visible.
+     */
+    setVisible?(visible: boolean): void;
+}
+
+interface IViewSize {
+    readonly width: number;
+    readonly height: number;
+}
+/**
+ * The interface to implement for views within a {@link GridView}.
+ */
+interface IView$1 {
+    /**
+     * The DOM element for this view.
+     */
+    readonly element: HTMLElement;
+    /**
+     * A minimum width for this view.
+     *
+     * @remarks If none, set it to `0`.
+     */
+    readonly minimumWidth: number;
+    /**
+     * A minimum width for this view.
+     *
+     * @remarks If none, set it to `Number.POSITIVE_INFINITY`.
+     */
+    readonly maximumWidth: number;
+    /**
+     * A minimum height for this view.
+     *
+     * @remarks If none, set it to `0`.
+     */
+    readonly minimumHeight: number;
+    /**
+     * A minimum height for this view.
+     *
+     * @remarks If none, set it to `Number.POSITIVE_INFINITY`.
+     */
+    readonly maximumHeight: number;
+    /**
+     * The priority of the view when the {@link GridView} layout algorithm
+     * runs. Views with higher priority will be resized first.
+     *
+     * @remarks Only used when `proportionalLayout` is false.
+     */
+    readonly priority?: LayoutPriority;
+    /**
+     * If the {@link GridView} supports proportional layout,
+     * this property allows for finer control over the proportional layout algorithm, per view.
+     *
+     * @defaultValue `true`
+     */
+    readonly proportionalLayout?: boolean;
+    /**
+     * Whether the view will snap whenever the user reaches its minimum size or
+     * attempts to grow it beyond the minimum size.
+     *
+     * @defaultValue `false`
+     */
+    readonly snap?: boolean;
+    /**
+     * View instances are supposed to fire this event whenever any of the constraint
+     * properties have changed:
+     *
+     * - {@link IView.minimumWidth}
+     * - {@link IView.maximumWidth}
+     * - {@link IView.minimumHeight}
+     * - {@link IView.maximumHeight}
+     * - {@link IView.priority}
+     * - {@link IView.snap}
+     *
+     * The {@link GridView} will relayout whenever that happens. The event can
+     * optionally emit the view's preferred size for that relayout.
+     */
+    readonly onDidChange: Event$1<IViewSize | undefined>;
+    /**
+     * This will be called by the {@link GridView} during layout. A view meant to
+     * pass along the layout information down to its descendants.
+     */
+    layout(width: number, height: number, top: number, left: number): void;
+    /**
+     * This will be called by the {@link GridView} whenever this view is made
+     * visible or hidden.
+     *
+     * @param visible Whether the view becomes visible.
+     */
+    setVisible?(visible: boolean): void;
+    /**
+     * This will be called by the {@link GridView} whenever this view is on
+     * an edge of the grid and the grid's
+     * {@link GridView.boundarySashes boundary sashes} change.
+     */
+    setBoundarySashes?(sashes: IBoundarySashes): void;
+}
+
+declare const enum Direction {
+    Up = 0,
+    Down = 1,
+    Left = 2,
+    Right = 3
+}
+/**
+ * The interface to implement for views within a {@link Grid}.
+ */
+interface IView extends IView$1 {
+    /**
+     * The preferred width for when the user double clicks a sash
+     * adjacent to this view.
+     */
+    readonly preferredWidth?: number;
+    /**
+     * The preferred height for when the user double clicks a sash
+     * adjacent to this view.
+     */
+    readonly preferredHeight?: number;
+}
+interface ISerializableView extends IView {
+    toJSON(): object;
+}
+
+interface IPartOptions {
+    readonly hasTitle?: boolean;
+    readonly borderWidth?: () => number;
+}
+interface ILayoutContentResult {
+    readonly titleSize: IDimension;
+    readonly contentSize: IDimension;
+}
+/**
+ * Parts are layed out in the workbench and have their own layout that
+ * arranges an optional title and mandatory content area to show content.
+ */
+declare abstract class Part extends Component implements ISerializableView {
+    private options;
+    protected readonly layoutService: IWorkbenchLayoutService;
+    private _dimension;
+    get dimension(): Dimension | undefined;
+    protected _onDidVisibilityChange: Emitter<boolean>;
+    readonly onDidVisibilityChange: Event$1<boolean>;
+    private parent;
+    private titleArea;
+    private contentArea;
+    private partLayout;
+    constructor(id: string, options: IPartOptions, themeService: IThemeService, storageService: IStorageService, layoutService: IWorkbenchLayoutService);
+    protected onThemeChange(theme: IColorTheme): void;
+    updateStyles(): void;
+    /**
+     * Note: Clients should not call this method, the workbench calls this
+     * method. Calling it otherwise may result in unexpected behavior.
+     *
+     * Called to create title and content area of the part.
+     */
+    create(parent: HTMLElement, options?: object): void;
+    /**
+     * Returns the overall part container.
+     */
+    getContainer(): HTMLElement | undefined;
+    /**
+     * Subclasses override to provide a title area implementation.
+     */
+    protected createTitleArea(parent: HTMLElement, options?: object): HTMLElement | undefined;
+    /**
+     * Returns the title area container.
+     */
+    protected getTitleArea(): HTMLElement | undefined;
+    /**
+     * Subclasses override to provide a content area implementation.
+     */
+    protected createContentArea(parent: HTMLElement, options?: object): HTMLElement | undefined;
+    /**
+     * Returns the content area container.
+     */
+    protected getContentArea(): HTMLElement | undefined;
+    /**
+     * Layout title and content area in the given dimension.
+     */
+    protected layoutContents(width: number, height: number): ILayoutContentResult;
+    protected _onDidChange: Emitter<IViewSize | undefined>;
+    get onDidChange(): Event$1<IViewSize | undefined>;
+    element: HTMLElement;
+    abstract minimumWidth: number;
+    abstract maximumWidth: number;
+    abstract minimumHeight: number;
+    abstract maximumHeight: number;
+    layout(width: number, height: number, _top: number, _left: number): void;
+    setVisible(visible: boolean): void;
+    abstract toJSON(): object;
+}
+
+declare const enum Parts {
+    TITLEBAR_PART = "workbench.parts.titlebar",
+    BANNER_PART = "workbench.parts.banner",
+    ACTIVITYBAR_PART = "workbench.parts.activitybar",
+    SIDEBAR_PART = "workbench.parts.sidebar",
+    PANEL_PART = "workbench.parts.panel",
+    AUXILIARYBAR_PART = "workbench.parts.auxiliarybar",
+    EDITOR_PART = "workbench.parts.editor",
+    STATUSBAR_PART = "workbench.parts.statusbar"
+}
+declare const enum Position {
+    LEFT = 0,
+    RIGHT = 1,
+    BOTTOM = 2
+}
+type PanelAlignment = 'left' | 'center' | 'right' | 'justify';
+
+declare const IWorkbenchLayoutService: ServiceIdentifier<IWorkbenchLayoutService>;
+interface IWorkbenchLayoutService extends ILayoutService {
+    readonly _serviceBrand: undefined;
+    /**
+     * Emits when the zen mode is enabled or disabled.
+     */
+    readonly onDidChangeZenMode: Event$1<boolean>;
+    /**
+     * Emits when fullscreen is enabled or disabled.
+     */
+    readonly onDidChangeFullscreen: Event$1<boolean>;
+    /**
+     * Emits when the window is maximized or unmaximized.
+     */
+    readonly onDidChangeWindowMaximized: Event$1<boolean>;
+    /**
+     * Emits when centered layout is enabled or disabled.
+     */
+    readonly onDidChangeCenteredLayout: Event$1<boolean>;
+    readonly onDidChangePanelPosition: Event$1<string>;
+    /**
+     * Emit when panel alignment changes.
+     */
+    readonly onDidChangePanelAlignment: Event$1<PanelAlignment>;
+    /**
+     * Emit when part visibility changes
+     */
+    readonly onDidChangePartVisibility: Event$1<void>;
+    /**
+     * Emit when notifications (toasts or center) visibility changes.
+     */
+    readonly onDidChangeNotificationsVisibility: Event$1<boolean>;
+    /**
+     * True if a default layout with default editors was applied at startup
+     */
+    readonly openedDefaultEditors: boolean;
+    /**
+     * Run a layout of the workbench.
+     */
+    layout(): void;
+    /**
+     * Asks the part service if all parts have been fully restored. For editor part
+     * this means that the contents of visible editors have loaded.
+     */
+    isRestored(): boolean;
+    /**
+     * A promise for to await the `isRestored()` condition to be `true`.
+     */
+    readonly whenRestored: Promise<void>;
+    /**
+     * Returns whether the given part has the keyboard focus or not.
+     */
+    hasFocus(part: Parts): boolean;
+    /**
+     * Focuses the part. If the part is not visible this is a noop.
+     */
+    focusPart(part: Parts): void;
+    /**
+     * Returns the parts HTML element, if there is one.
+     */
+    getContainer(part: Parts): HTMLElement | undefined;
+    /**
+     * Returns if the part is visible.
+     */
+    isVisible(part: Parts): boolean;
+    /**
+     * Returns if the part is visible.
+     */
+    getDimension(part: Parts): Dimension | undefined;
+    /**
+     * Set part hidden or not
+     */
+    setPartHidden(hidden: boolean, part: Exclude<Parts, Parts.STATUSBAR_PART | Parts.TITLEBAR_PART>): void;
+    /**
+     * Maximizes the panel height if the panel is not already maximized.
+     * Shrinks the panel to the default starting size if the panel is maximized.
+     */
+    toggleMaximizedPanel(): void;
+    /**
+     * Returns true if the window has a border.
+     */
+    hasWindowBorder(): boolean;
+    /**
+     * Returns the window border width.
+     */
+    getWindowBorderWidth(): number;
+    /**
+     * Returns the window border radius if any.
+     */
+    getWindowBorderRadius(): string | undefined;
+    /**
+     * Returns true if the panel is maximized.
+     */
+    isPanelMaximized(): boolean;
+    /**
+     * Gets the current side bar position. Note that the sidebar can be hidden too.
+     */
+    getSideBarPosition(): Position;
+    /**
+     * Toggles the menu bar visibility.
+     */
+    toggleMenuBar(): void;
+    getPanelPosition(): Position;
+    /**
+     * Sets the panel position.
+     */
+    setPanelPosition(position: Position): void;
+    /**
+     * Gets the panel alignement.
+     */
+    getPanelAlignment(): PanelAlignment;
+    /**
+     * Sets the panel alignment.
+     */
+    setPanelAlignment(alignment: PanelAlignment): void;
+    /**
+     * Gets the maximum possible size for editor.
+     */
+    getMaximumEditorDimensions(): Dimension;
+    /**
+     * Toggles the workbench in and out of zen mode - parts get hidden and window goes fullscreen.
+     */
+    toggleZenMode(): void;
+    /**
+     * Returns whether the centered editor layout is active.
+     */
+    isEditorLayoutCentered(): boolean;
+    /**
+     * Sets the workbench in and out of centered editor layout.
+     */
+    centerEditorLayout(active: boolean): void;
+    /**
+     * Resizes currently focused part on main access
+     */
+    resizePart(part: Parts, sizeChangeWidth: number, sizeChangeHeight: number): void;
+    /**
+     * Register a part to participate in the layout.
+     */
+    registerPart(part: Part): void;
+    /**
+     * Returns whether the window is maximized.
+     */
+    isWindowMaximized(): boolean;
+    /**
+     * Updates the maximized state of the window.
+     */
+    updateWindowMaximizedState(maximized: boolean): void;
+    /**
+     * Returns the next visible view part in a given direction
+     */
+    getVisibleNeighborPart(part: Parts, direction: Direction): Parts | undefined;
+}
+
+interface IAnchor {
+    x: number;
+    y: number;
+    width?: number;
+    height?: number;
+}
+declare const enum AnchorAlignment {
+    LEFT = 0,
+    RIGHT = 1
+}
+declare const enum AnchorPosition {
+    BELOW = 0,
+    ABOVE = 1
+}
+declare const enum AnchorAxisAlignment {
+    VERTICAL = 0,
+    HORIZONTAL = 1
+}
+interface IDelegate {
+    getAnchor(): HTMLElement | IAnchor;
+    render(container: HTMLElement): IDisposable | null;
+    focus?(): void;
+    layout?(): void;
+    anchorAlignment?: AnchorAlignment;
+    anchorPosition?: AnchorPosition;
+    anchorAxisAlignment?: AnchorAxisAlignment;
+    canRelayout?: boolean;
+    onDOMEvent?(e: Event, activeElement: HTMLElement): void;
+    onHide?(data?: unknown): void;
+}
+interface IContextViewProvider {
+    showContextView(delegate: IDelegate, container?: HTMLElement): void;
+    hideContextView(): void;
+    layout(): void;
+}
+
+declare abstract class Widget extends Disposable {
+    protected onclick(domNode: HTMLElement, listener: (e: IMouseEvent) => void): void;
+    protected onmousedown(domNode: HTMLElement, listener: (e: IMouseEvent) => void): void;
+    protected onmouseover(domNode: HTMLElement, listener: (e: IMouseEvent) => void): void;
+    protected onmouseleave(domNode: HTMLElement, listener: (e: IMouseEvent) => void): void;
+    protected onkeydown(domNode: HTMLElement, listener: (e: IKeyboardEvent) => void): void;
+    protected onkeyup(domNode: HTMLElement, listener: (e: IKeyboardEvent) => void): void;
+    protected oninput(domNode: HTMLElement, listener: (e: Event) => void): void;
+    protected onblur(domNode: HTMLElement, listener: (e: Event) => void): void;
+    protected onfocus(domNode: HTMLElement, listener: (e: Event) => void): void;
+    protected onchange(domNode: HTMLElement, listener: (e: Event) => void): void;
+    protected ignoreGesture(domNode: HTMLElement): IDisposable;
+}
+
+declare const enum HoverPosition {
+    LEFT = 0,
+    RIGHT = 1,
+    BELOW = 2,
+    ABOVE = 3
+}
+
+/**
+ * Copied from src\vs\workbench\services\hover\browser\hover.ts
+ * @deprecated Use IHoverService
+ */
+interface IHoverAction {
+    label: string;
+    commandId: string;
+    iconClass?: string;
+    run(target: HTMLElement): void;
+}
+interface IUpdatableHoverOptions {
+    actions?: IHoverAction[];
+    linkHandler?(url: string): void;
+}
+
+interface IHoverDelegateTarget extends IDisposable {
+    readonly targetElements: readonly HTMLElement[];
+    x?: number;
+}
+interface IHoverDelegateOptions extends IUpdatableHoverOptions {
+    /**
+     * The content to display in the primary section of the hover. The type of text determines the
+     * default `hideOnHover` behavior.
+     */
+    content: IMarkdownString | string | HTMLElement;
+    /**
+     * The target for the hover. This determines the position of the hover and it will only be
+     * hidden when the mouse leaves both the hover and the target. A HTMLElement can be used for
+     * simple cases and a IHoverDelegateTarget for more complex cases where multiple elements and/or a
+     * dispose method is required.
+     */
+    target: IHoverDelegateTarget | HTMLElement;
+    /**
+     * Position of the hover. The default is to show above the target. This option will be ignored
+     * if there is not enough room to layout the hover in the specified position, unless the
+     * forcePosition option is set.
+     */
+    hoverPosition?: HoverPosition;
+    /**
+     * Whether to show the hover pointer
+     */
+    showPointer?: boolean;
+    /**
+     * Whether to skip the fade in animation, this should be used when hovering from one hover to
+     * another in the same group so it looks like the hover is moving from one element to the other.
+     */
+    skipFadeInAnimation?: boolean;
+    /**
+     * The container to pass to {@link IContextViewProvider.showContextView} which renders the hover
+     * in. This is particularly useful for more natural tab focusing behavior, where the hover is
+     * created as the next tab index after the element being hovered and/or to workaround the
+     * element's container hiding on `focusout`.
+     */
+    container?: HTMLElement;
+}
+interface IHoverDelegate {
+    showHover(options: IHoverDelegateOptions, focus?: boolean): IHoverWidget | undefined;
+    onDidHideHover?: () => void;
+    delay: number;
+    placement?: 'mouse' | 'element';
+}
+interface IHoverWidget extends IDisposable {
+    readonly isDisposed: boolean;
+}
+
+interface IToggleStyles {
+    readonly inputActiveOptionBorder: string | undefined;
+    readonly inputActiveOptionForeground: string | undefined;
+    readonly inputActiveOptionBackground: string | undefined;
+}
+
+interface IBaseActionViewItemOptions {
+    draggable?: boolean;
+    isMenu?: boolean;
+    useEventAsContext?: boolean;
+    hoverDelegate?: IHoverDelegate;
+}
+interface IActionViewItemOptions extends IBaseActionViewItemOptions {
+    icon?: boolean;
+    label?: boolean;
+    keybinding?: string | null;
+    toggleStyles?: IToggleStyles;
+}
+
+interface IActionViewItem extends IDisposable {
+    action: IAction;
+    actionRunner: IActionRunner;
+    setActionContext(context: unknown): void;
+    render(element: HTMLElement): void;
+    isEnabled(): boolean;
+    focus(fromRight?: boolean): void;
+    blur(): void;
+}
+interface IActionViewItemProvider {
+    (action: IAction, options: IActionViewItemOptions): IActionViewItem | undefined;
+}
+
+/**
+ * Composites are layed out in the sidebar and panel part of the workbench. At a time only one composite
+ * can be open in the sidebar, and only one composite can be open in the panel.
+ *
+ * Each composite has a minimized representation that is good enough to provide some
+ * information about the state of the composite data.
+ *
+ * The workbench will keep a composite alive after it has been created and show/hide it based on
+ * user interaction. The lifecycle of a composite goes in the order create(), setVisible(true|false),
+ * layout(), focus(), dispose(). During use of the workbench, a composite will often receive a setVisible,
+ * layout and focus call, but only one create and dispose call.
+ */
+declare abstract class Composite extends Component implements IComposite {
+    private readonly _onTitleAreaUpdate;
+    readonly onTitleAreaUpdate: Event$1<void>;
+    private _onDidFocus;
+    get onDidFocus(): Event$1<void>;
+    protected fireOnDidFocus(): void;
+    private _onDidBlur;
+    get onDidBlur(): Event$1<void>;
+    private _hasFocus;
+    hasFocus(): boolean;
+    private registerFocusTrackEvents;
+    protected actionRunner: IActionRunner | undefined;
+    private _telemetryService;
+    protected get telemetryService(): ITelemetryService;
+    private visible;
+    private parent;
+    constructor(id: string, telemetryService: ITelemetryService, themeService: IThemeService, storageService: IStorageService);
+    getTitle(): string | undefined;
+    /**
+     * Note: Clients should not call this method, the workbench calls this
+     * method. Calling it otherwise may result in unexpected behavior.
+     *
+     * Called to create this composite on the provided parent. This method is only
+     * called once during the lifetime of the workbench.
+     * Note that DOM-dependent calculations should be performed from the setVisible()
+     * call. Only then the composite will be part of the DOM.
+     */
+    create(parent: HTMLElement): void;
+    /**
+     * Returns the container this composite is being build in.
+     */
+    getContainer(): HTMLElement | undefined;
+    /**
+     * Note: Clients should not call this method, the workbench calls this
+     * method. Calling it otherwise may result in unexpected behavior.
+     *
+     * Called to indicate that the composite has become visible or hidden. This method
+     * is called more than once during workbench lifecycle depending on the user interaction.
+     * The composite will be on-DOM if visible is set to true and off-DOM otherwise.
+     *
+     * Typically this operation should be fast though because setVisible might be called many times during a session.
+     * If there is a long running operation it is fine to have it running in the background asyncly and return before.
+     */
+    setVisible(visible: boolean): void;
+    /**
+     * Called when this composite should receive keyboard focus.
+     */
+    focus(): void;
+    /**
+     * Layout the contents of this composite using the provided dimensions.
+     */
+    abstract layout(dimension: Dimension, position?: IDomPosition): void;
+    /**
+     * Set boundary sashes for this composite. These are used to create
+     * draggable corner areas with inner sashes.
+     */
+    abstract setBoundarySashes(sashes: IBoundarySashes): void;
+    /**
+     * Update the styles of the contents of this composite.
+     */
+    updateStyles(): void;
+    /**
+     *
+     * @returns the action runner for this composite
+     */
+    getMenuIds(): readonly MenuId[];
+    /**
+     * Returns an array of actions to show in the action bar of the composite.
+     */
+    getActions(): readonly IAction[];
+    /**
+     * Returns an array of actions to show in the action bar of the composite
+     * in a less prominent way then action from getActions.
+     */
+    getSecondaryActions(): readonly IAction[];
+    /**
+     * Returns an array of actions to show in the context menu of the composite
+     */
+    getContextMenuActions(): readonly IAction[];
+    /**
+     * For any of the actions returned by this composite, provide an IActionViewItem in
+     * cases where the implementor of the composite wants to override the presentation
+     * of an action. Returns undefined to indicate that the action is not rendered through
+     * an action item.
+     */
+    getActionViewItem(action: IAction): IActionViewItem | undefined;
+    /**
+     * Provide a context to be passed to the toolbar.
+     */
+    getActionsContext(): unknown;
+    /**
+     * Returns the instance of IActionRunner to use with this composite for the
+     * composite tool bar.
+     */
+    getActionRunner(): IActionRunner;
+    /**
+     * Method for composite implementors to indicate to the composite container that the title or the actions
+     * of the composite have changed. Calling this method will cause the container to ask for title (getTitle())
+     * and actions (getActions(), getSecondaryActions()) if the composite is visible or the next time the composite
+     * gets visible.
+     */
+    protected updateTitleArea(): void;
+    /**
+     * Returns true if this composite is currently visible and false otherwise.
+     */
+    isVisible(): boolean;
+    /**
+     * Returns the underlying composite control or `undefined` if it is not accessible.
+     */
+    getControl(): ICompositeControl | undefined;
+}
+/**
+ * A composite descriptor is a lightweight descriptor of a composite in the workbench.
+ */
+declare abstract class CompositeDescriptor<T extends Composite> {
+    private readonly ctor;
+    readonly id: string;
+    readonly name: string;
+    readonly cssClass?: string | undefined;
+    readonly order?: number | undefined;
+    readonly requestedIndex?: number | undefined;
+    constructor(ctor: IConstructorSignature<T>, id: string, name: string, cssClass?: string | undefined, order?: number | undefined, requestedIndex?: number | undefined);
+    instantiate(instantiationService: IInstantiationService): T;
+}
+
+interface IContextMenuEvent {
+    readonly shiftKey?: boolean;
+    readonly ctrlKey?: boolean;
+    readonly altKey?: boolean;
+    readonly metaKey?: boolean;
+}
+interface IContextMenuDelegate {
+    getAnchor(): HTMLElement | {
+        x: number;
+        y: number;
+        width?: number;
+        height?: number;
+    };
+    getActions(): readonly IAction[];
+    getCheckedActionsRepresentation?(action: IAction): 'radio' | 'checkbox';
+    getActionViewItem?(action: IAction, options: IActionViewItemOptions): IActionViewItem | undefined;
+    getActionsContext?(event?: IContextMenuEvent): unknown;
+    getKeyBinding?(action: IAction): ResolvedKeybinding | undefined;
+    getMenuClassName?(): string;
+    onHide?(didCancel: boolean): void;
+    actionRunner?: IActionRunner;
+    skipTelemetry?: boolean;
+    autoSelectFirstItem?: boolean;
+    anchorAlignment?: AnchorAlignment;
+    anchorAxisAlignment?: AnchorAxisAlignment;
+    domForShadowRoot?: HTMLElement;
+}
+
+declare const IContextViewService: ServiceIdentifier<IContextViewService>;
+interface IContextViewService extends IContextViewProvider {
+    readonly _serviceBrand: undefined;
+    showContextView(delegate: IContextViewDelegate, container?: HTMLElement, shadowRoot?: boolean): IDisposable;
+    hideContextView(data?: any): void;
+    getContextViewElement(): HTMLElement;
+    layout(): void;
+    anchorAlignment?: AnchorAlignment;
+}
+interface IContextViewDelegate {
+    canRelayout?: boolean;
+    getAnchor(): HTMLElement | {
+        x: number;
+        y: number;
+        width?: number;
+        height?: number;
+    };
+    render(container: HTMLElement): IDisposable;
+    onDOMEvent?(e: any, activeElement: HTMLElement): void;
+    onHide?(data?: any): void;
+    focus?(): void;
+    anchorAlignment?: AnchorAlignment;
+    anchorAxisAlignment?: AnchorAxisAlignment;
+}
+declare const IContextMenuService: ServiceIdentifier<IContextMenuService>;
+interface IContextMenuService {
+    readonly _serviceBrand: undefined;
+    readonly onDidShowContextMenu: Event$1<void>;
+    readonly onDidHideContextMenu: Event$1<void>;
+    showContextMenu(delegate: IContextMenuDelegate | IContextMenuMenuDelegate): void;
+}
+type IContextMenuMenuDelegate = {
+    /**
+     * The MenuId that should be used to populate the context menu.
+     */
+    menuId?: MenuId;
+    /**
+     * Optional options how menu actions are invoked
+     */
+    menuActionOptions?: IMenuActionOptions;
+    /**
+     * Optional context key service which drives the given menu
+     */
+    contextKeyService?: IContextKeyService;
+    /**
+     * Optional getter for extra actions. They will be prepended to the menu actions.
+     */
+    getActions?(): IAction[];
+} & Omit<IContextMenuDelegate, 'getActions'>;
+
+interface IPaneOptions {
+    minimumBodySize?: number;
+    maximumBodySize?: number;
+    expanded?: boolean;
+    orientation?: Orientation;
+    title: string;
+    titleDescription?: string;
+}
+interface IPaneStyles {
+    readonly dropBackground: string | undefined;
+    readonly headerForeground: string | undefined;
+    readonly headerBackground: string | undefined;
+    readonly headerBorder: string | undefined;
+    readonly leftBorder: string | undefined;
+}
+/**
+ * A Pane is a structured SplitView view.
+ *
+ * WARNING: You must call `render()` after you construct it.
+ * It can't be done automatically at the end of the ctor
+ * because of the order of property initialization in TypeScript.
+ * Subclasses wouldn't be able to set own properties
+ * before the `render()` call, thus forbidding their use.
+ */
+declare abstract class Pane extends Disposable implements IView$2 {
+    private static readonly HEADER_SIZE;
+    readonly element: HTMLElement;
+    private header;
+    private body;
+    protected _expanded: boolean;
+    protected _orientation: Orientation;
+    private expandedSize;
+    private _headerVisible;
+    private _bodyRendered;
+    private _minimumBodySize;
+    private _maximumBodySize;
+    private _ariaHeaderLabel;
+    private styles;
+    private animationTimer;
+    private readonly _onDidChange;
+    readonly onDidChange: Event$1<number | undefined>;
+    private readonly _onDidChangeExpansionState;
+    readonly onDidChangeExpansionState: Event$1<boolean>;
+    get ariaHeaderLabel(): string;
+    set ariaHeaderLabel(newLabel: string);
+    get draggableElement(): HTMLElement;
+    get dropTargetElement(): HTMLElement;
+    get dropBackground(): string | undefined;
+    get minimumBodySize(): number;
+    set minimumBodySize(size: number);
+    get maximumBodySize(): number;
+    set maximumBodySize(size: number);
+    private get headerSize();
+    get minimumSize(): number;
+    get maximumSize(): number;
+    orthogonalSize: number;
+    constructor(options: IPaneOptions);
+    isExpanded(): boolean;
+    setExpanded(expanded: boolean): boolean;
+    get headerVisible(): boolean;
+    set headerVisible(visible: boolean);
+    get orientation(): Orientation;
+    set orientation(orientation: Orientation);
+    render(): void;
+    layout(size: number): void;
+    style(styles: IPaneStyles): void;
+    protected updateHeader(): void;
+    protected abstract renderHeader(container: HTMLElement): void;
+    protected abstract renderBody(container: HTMLElement): void;
+    protected abstract layoutBody(height: number, width: number): void;
+}
+interface IPaneDndController {
+    canDrag(pane: Pane): boolean;
+    canDrop(pane: Pane, overPane: Pane): boolean;
+}
+interface IPaneViewOptions {
+    dnd?: IPaneDndController;
+    orientation?: Orientation;
+}
+
+declare class CompositeMenuActions extends Disposable {
+    readonly menuId: MenuId;
+    private readonly contextMenuId;
+    private readonly options;
+    private readonly contextKeyService;
+    private readonly menuService;
+    private readonly menuActions;
+    private _onDidChange;
+    readonly onDidChange: Event$1<void>;
+    constructor(menuId: MenuId, contextMenuId: MenuId | undefined, options: IMenuActionOptions | undefined, contextKeyService: IContextKeyService, menuService: IMenuService);
+    getPrimaryActions(): IAction[];
+    getSecondaryActions(): IAction[];
+    getContextMenuActions(): IAction[];
+}
+
+interface IKeybindingProvider {
+    (action: IAction): ResolvedKeybinding | undefined;
+}
+interface IAnchorAlignmentProvider {
+    (): AnchorAlignment;
+}
+interface IDropdownMenuActionViewItemOptions extends IBaseActionViewItemOptions {
+    readonly actionViewItemProvider?: IActionViewItemProvider;
+    readonly keybindingProvider?: IKeybindingProvider;
+    readonly actionRunner?: IActionRunner;
+    readonly classNames?: string[] | string;
+    readonly anchorAlignmentProvider?: IAnchorAlignmentProvider;
+    readonly menuAsChild?: boolean;
+}
+
+interface IFilterWidgetOptions {
+    readonly text?: string;
+    readonly placeholder?: string;
+    readonly ariaLabel?: string;
+    readonly history?: string[];
+    readonly focusContextKey?: string;
+}
+declare class FilterWidget extends Widget {
+    private readonly options;
+    private readonly instantiationService;
+    private readonly contextViewService;
+    private readonly keybindingService;
+    readonly element: HTMLElement;
+    private readonly delayedFilterUpdate;
+    private readonly filterInputBox;
+    private readonly filterBadge;
+    private readonly toolbar;
+    private readonly focusContextKey;
+    private readonly _onDidChangeFilterText;
+    readonly onDidChangeFilterText: Event$1<string>;
+    private moreFiltersActionViewItem;
+    private isMoreFiltersChecked;
+    constructor(options: IFilterWidgetOptions, instantiationService: IInstantiationService, contextViewService: IContextViewService, contextKeyService: IContextKeyService, keybindingService: IKeybindingService);
+    focus(): void;
+    blur(): void;
+    updateBadge(message: string | undefined): void;
+    setFilterText(filterText: string): void;
+    getFilterText(): string;
+    getHistory(): string[];
+    layout(width: number): void;
+    checkMoreFilters(checked: boolean): void;
+    private createInput;
+    private createBadge;
+    private createToolBar;
+    private onDidInputChange;
+    private adjustInputBox;
+    private handleKeyboardEvent;
+    private onInputKeyDown;
+}
+
+interface IViewPaneOptions extends IPaneOptions {
+    id: string;
+    showActionsAlways?: boolean;
+    titleMenuId?: MenuId;
+    donotForwardArgs?: boolean;
+}
+declare abstract class ViewPane extends Pane implements IView$3 {
+    protected keybindingService: IKeybindingService;
+    protected contextMenuService: IContextMenuService;
+    protected readonly configurationService: IConfigurationService;
+    protected contextKeyService: IContextKeyService;
+    protected viewDescriptorService: IViewDescriptorService;
+    protected instantiationService: IInstantiationService;
+    protected openerService: IOpenerService;
+    protected themeService: IThemeService;
+    protected telemetryService: ITelemetryService;
+    private static readonly AlwaysShowActionsConfig;
+    private _onDidFocus;
+    readonly onDidFocus: Event$1<void>;
+    private _onDidBlur;
+    readonly onDidBlur: Event$1<void>;
+    private _onDidChangeBodyVisibility;
+    readonly onDidChangeBodyVisibility: Event$1<boolean>;
+    protected _onDidChangeTitleArea: Emitter<void>;
+    readonly onDidChangeTitleArea: Event$1<void>;
+    protected _onDidChangeViewWelcomeState: Emitter<void>;
+    readonly onDidChangeViewWelcomeState: Event$1<void>;
+    private _isVisible;
+    readonly id: string;
+    private _title;
+    get title(): string;
+    private _titleDescription;
+    get titleDescription(): string | undefined;
+    readonly menuActions: CompositeMenuActions;
+    private progressBar;
+    private progressIndicator;
+    private toolbar?;
+    private readonly showActionsAlways;
+    private headerContainer?;
+    private titleContainer?;
+    private titleDescriptionContainer?;
+    private iconContainer?;
+    protected twistiesContainer?: HTMLElement;
+    private bodyContainer;
+    private viewWelcomeContainer;
+    private viewWelcomeDisposable;
+    private viewWelcomeController;
+    protected readonly scopedContextKeyService: IContextKeyService;
+    constructor(options: IViewPaneOptions, keybindingService: IKeybindingService, contextMenuService: IContextMenuService, configurationService: IConfigurationService, contextKeyService: IContextKeyService, viewDescriptorService: IViewDescriptorService, instantiationService: IInstantiationService, openerService: IOpenerService, themeService: IThemeService, telemetryService: ITelemetryService);
+    get headerVisible(): boolean;
+    set headerVisible(visible: boolean);
+    setVisible(visible: boolean): void;
+    isVisible(): boolean;
+    isBodyVisible(): boolean;
+    setExpanded(expanded: boolean): boolean;
+    render(): void;
+    protected renderHeader(container: HTMLElement): void;
+    protected getTwistyIcon(expanded: boolean): ThemeIcon;
+    style(styles: IPaneStyles): void;
+    private getIcon;
+    protected renderHeaderTitle(container: HTMLElement, title: string): void;
+    protected updateTitle(title: string): void;
+    private setTitleDescription;
+    protected updateTitleDescription(description?: string | undefined): void;
+    private calculateTitle;
+    private scrollableElement;
+    protected renderBody(container: HTMLElement): void;
+    protected layoutBody(height: number, width: number): void;
+    onDidScrollRoot(): void;
+    getProgressIndicator(): IProgressIndicator;
+    protected getProgressLocation(): string;
+    protected getBackgroundColor(): string;
+    focus(): void;
+    private setActions;
+    private updateActionsVisibility;
+    protected updateActions(): void;
+    getActionViewItem(action: IAction, options?: IDropdownMenuActionViewItemOptions): IActionViewItem | undefined;
+    getActionsContext(): unknown;
+    getActionRunner(): IActionRunner | undefined;
+    getOptimalWidth(): number;
+    saveState(): void;
+    private updateViewWelcome;
+    shouldShowWelcome(): boolean;
+    getFilterWidget(): FilterWidget | undefined;
+    shouldShowFilterInHeader(): boolean;
+}
+
+interface IViewletViewOptions extends IViewPaneOptions {
+    readonly fromExtensionId?: ExtensionIdentifier;
+}
+
+interface IViewPaneContainerOptions extends IPaneViewOptions {
+    mergeViewWithContainerWhenSingleView: boolean;
+}
+declare class ViewPaneContainer extends Component implements IViewPaneContainer {
+    private options;
+    protected instantiationService: IInstantiationService;
+    protected configurationService: IConfigurationService;
+    protected layoutService: IWorkbenchLayoutService;
+    protected contextMenuService: IContextMenuService;
+    protected telemetryService: ITelemetryService;
+    protected extensionService: IExtensionService;
+    protected storageService: IStorageService;
+    protected contextService: IWorkspaceContextService;
+    protected viewDescriptorService: IViewDescriptorService;
+    readonly viewContainer: ViewContainer;
+    private lastFocusedPane;
+    private lastMergedCollapsedPane;
+    private paneItems;
+    private paneview?;
+    private visible;
+    private areExtensionsReady;
+    private didLayout;
+    private dimension;
+    private _boundarySashes;
+    private readonly visibleViewsCountFromCache;
+    private readonly visibleViewsStorageId;
+    protected readonly viewContainerModel: IViewContainerModel;
+    private viewDisposables;
+    private readonly _onTitleAreaUpdate;
+    readonly onTitleAreaUpdate: Event$1<void>;
+    private readonly _onDidChangeVisibility;
+    readonly onDidChangeVisibility: Event$1<boolean>;
+    private readonly _onDidAddViews;
+    readonly onDidAddViews: Event$1<IView$3[]>;
+    private readonly _onDidRemoveViews;
+    readonly onDidRemoveViews: Event$1<IView$3[]>;
+    private readonly _onDidChangeViewVisibility;
+    readonly onDidChangeViewVisibility: Event$1<IView$3>;
+    private readonly _onDidFocusView;
+    readonly onDidFocusView: Event$1<IView$3>;
+    private readonly _onDidBlurView;
+    readonly onDidBlurView: Event$1<IView$3>;
+    get onDidSashChange(): Event$1<number>;
+    get panes(): ViewPane[];
+    get views(): IView$3[];
+    get length(): number;
+    private _menuActions?;
+    get menuActions(): CompositeMenuActions | undefined;
+    constructor(id: string, options: IViewPaneContainerOptions, instantiationService: IInstantiationService, configurationService: IConfigurationService, layoutService: IWorkbenchLayoutService, contextMenuService: IContextMenuService, telemetryService: ITelemetryService, extensionService: IExtensionService, themeService: IThemeService, storageService: IStorageService, contextService: IWorkspaceContextService, viewDescriptorService: IViewDescriptorService);
+    create(parent: HTMLElement): void;
+    getTitle(): string;
+    private showContextMenu;
+    getActionsContext(): unknown;
+    getActionViewItem(action: IAction): IActionViewItem | undefined;
+    focus(): void;
+    private get orientation();
+    layout(dimension: Dimension): void;
+    setBoundarySashes(sashes: IBoundarySashes): void;
+    getOptimalWidth(): number;
+    addPanes(panes: {
+        pane: ViewPane;
+        size: number;
+        index?: number;
+    }[]): void;
+    setVisible(visible: boolean): void;
+    isVisible(): boolean;
+    protected updateTitleArea(): void;
+    protected createView(viewDescriptor: IViewDescriptor, options: IViewletViewOptions): ViewPane;
+    getView(id: string): ViewPane | undefined;
+    private saveViewSizes;
+    private restoreViewSizes;
+    private computeInitialSizes;
+    protected saveState(): void;
+    private onContextMenu;
+    openView(id: string, focus?: boolean): IView$3 | undefined;
+    protected onDidAddViewDescriptors(added: IAddedViewDescriptorRef[]): ViewPane[];
+    private onDidRemoveViewDescriptors;
+    toggleViewVisibility(viewId: string): void;
+    private addPane;
+    removePanes(panes: ViewPane[]): void;
+    private removePane;
+    movePane(from: ViewPane, to: ViewPane): void;
+    resizePane(pane: ViewPane, size: number): void;
+    getPaneSize(pane: ViewPane): number;
+    private updateViewHeaders;
+    isViewMergedWithContainer(): boolean;
+    private onDidScrollPane;
+    private onDidSashReset;
+    dispose(): void;
+}
+
+declare abstract class PaneComposite extends Composite implements IPaneComposite {
+    protected storageService: IStorageService;
+    protected instantiationService: IInstantiationService;
+    protected contextMenuService: IContextMenuService;
+    protected extensionService: IExtensionService;
+    protected contextService: IWorkspaceContextService;
+    private viewPaneContainer?;
+    constructor(id: string, telemetryService: ITelemetryService, storageService: IStorageService, instantiationService: IInstantiationService, themeService: IThemeService, contextMenuService: IContextMenuService, extensionService: IExtensionService, contextService: IWorkspaceContextService);
+    create(parent: HTMLElement): void;
+    setVisible(visible: boolean): void;
+    layout(dimension: Dimension): void;
+    setBoundarySashes(sashes: IBoundarySashes): void;
+    getOptimalWidth(): number;
+    openView<T extends IView$3>(id: string, focus?: boolean): T | undefined;
+    getViewPaneContainer(): ViewPaneContainer | undefined;
+    getActionsContext(): unknown;
+    getContextMenuActions(): readonly IAction[];
+    getMenuIds(): MenuId[];
+    getActions(): readonly IAction[];
+    getSecondaryActions(): readonly IAction[];
+    getActionViewItem(action: IAction): IActionViewItem | undefined;
+    getTitle(): string;
+    focus(): void;
+    protected abstract createViewPaneContainer(parent: HTMLElement): ViewPaneContainer;
+}
+/**
+ * A Pane Composite descriptor is a lightweight descriptor of a Pane Composite in the workbench.
+ */
+declare class PaneCompositeDescriptor extends CompositeDescriptor<PaneComposite> {
+    readonly iconUrl?: URI | undefined;
+    static create<Services extends BrandedService[]>(ctor: {
+        new (...services: Services): PaneComposite;
+    }, id: string, name: string, cssClass?: string, order?: number, requestedIndex?: number, iconUrl?: URI): PaneCompositeDescriptor;
+    private constructor();
+}
+
+interface IBadge {
+    getDescription(): string;
+}
+
+declare const IPaneCompositePartService: ServiceIdentifier<IPaneCompositePartService>;
+interface IPaneCompositePartService {
+    readonly _serviceBrand: undefined;
+    readonly onDidPaneCompositeOpen: Event$1<{
+        composite: IPaneComposite;
+        viewContainerLocation: ViewContainerLocation;
+    }>;
+    readonly onDidPaneCompositeClose: Event$1<{
+        composite: IPaneComposite;
+        viewContainerLocation: ViewContainerLocation;
+    }>;
+    /**
+     * Opens a viewlet with the given identifier and pass keyboard focus to it if specified.
+     */
+    openPaneComposite(id: string | undefined, viewContainerLocation: ViewContainerLocation, focus?: boolean): Promise<IPaneComposite | undefined>;
+    /**
+     * Returns the current active viewlet if any.
+     */
+    getActivePaneComposite(viewContainerLocation: ViewContainerLocation): IPaneComposite | undefined;
+    /**
+     * Returns the viewlet by id.
+     */
+    getPaneComposite(id: string, viewContainerLocation: ViewContainerLocation): PaneCompositeDescriptor | undefined;
+    /**
+     * Returns all enabled viewlets
+     */
+    getPaneComposites(viewContainerLocation: ViewContainerLocation): PaneCompositeDescriptor[];
+    /**
+     * Returns id of pinned view containers following the visual order.
+     */
+    getPinnedPaneCompositeIds(viewContainerLocation: ViewContainerLocation): string[];
+    /**
+     * Returns id of visible view containers following the visual order.
+     */
+    getVisiblePaneCompositeIds(viewContainerLocation: ViewContainerLocation): string[];
+    /**
+     * Returns the progress indicator for the side bar.
+     */
+    getProgressIndicator(id: string, viewContainerLocation: ViewContainerLocation): IProgressIndicator | undefined;
+    /**
+     * Hide the active viewlet.
      */
     hideActivePaneComposite(viewContainerLocation: ViewContainerLocation): void;
     /**
@@ -2538,14 +5130,14 @@ interface IPaneCompositePartService {
 declare const ICodeEditorService: ServiceIdentifier<ICodeEditorService>;
 interface ICodeEditorService {
     readonly _serviceBrand: undefined;
-    readonly onWillCreateCodeEditor: Event<void>;
-    readonly onCodeEditorAdd: Event<ICodeEditor>;
-    readonly onCodeEditorRemove: Event<ICodeEditor>;
-    readonly onWillCreateDiffEditor: Event<void>;
-    readonly onDiffEditorAdd: Event<IDiffEditor$1>;
-    readonly onDiffEditorRemove: Event<IDiffEditor$1>;
-    readonly onDidChangeTransientModelProperty: Event<ITextModel>;
-    readonly onDecorationTypeRegistered: Event<string>;
+    readonly onWillCreateCodeEditor: Event$1<void>;
+    readonly onCodeEditorAdd: Event$1<ICodeEditor>;
+    readonly onCodeEditorRemove: Event$1<ICodeEditor>;
+    readonly onWillCreateDiffEditor: Event$1<void>;
+    readonly onDiffEditorAdd: Event$1<IDiffEditor$1>;
+    readonly onDiffEditorRemove: Event$1<IDiffEditor$1>;
+    readonly onDidChangeTransientModelProperty: Event$1<ITextModel>;
+    readonly onDecorationTypeRegistered: Event$1<string>;
     willCreateCodeEditor(): void;
     addCodeEditor(editor: ICodeEditor): void;
     removeCodeEditor(editor: ICodeEditor): void;
@@ -2590,6 +5182,10 @@ interface IExtensionResourceLoaderService {
      * Returns whether the gallery provides extension resources.
      */
     readonly supportsExtensionGalleryResources: boolean;
+    /**
+     * Return true if the given URI is a extension gallery resource.
+     */
+    isExtensionGalleryResource(uri: URI): boolean;
     /**
      * Computes the URL of a extension gallery resource. Returns `undefined` if gallery does not provide extension resources.
      */
@@ -2597,6 +5193,7 @@ interface IExtensionResourceLoaderService {
         publisher: string;
         name: string;
         version: string;
+        targetPlatform?: TargetPlatform;
     }, path?: string): URI | undefined;
 }
 
@@ -2670,7 +5267,7 @@ interface IAudioCueService {
     playAudioCue(cue: AudioCue, allowManyInParallel?: boolean): Promise<void>;
     playAudioCues(cues: AudioCue[]): Promise<void>;
     isEnabled(cue: AudioCue): boolean;
-    onEnabledChanged(cue: AudioCue): Event<void>;
+    onEnabledChanged(cue: AudioCue): Event$1<void>;
     playSound(cue: Sound, allowManyInParallel?: boolean): Promise<void>;
 }
 /**
@@ -2719,11 +5316,30 @@ declare class AudioCue {
     private constructor();
 }
 
+declare const IPreferencesSearchService: ServiceIdentifier<IPreferencesSearchService>;
+interface IPreferencesSearchService {
+    readonly _serviceBrand: undefined;
+    getLocalSearchProvider(filter: string): ISearchProvider;
+    getRemoteSearchProvider(filter: string, newExtensionsOnly?: boolean): ISearchProvider | undefined;
+}
+interface ISearchProvider {
+    searchModel(preferencesModel: ISettingsEditorModel, token?: CancellationToken): Promise<ISearchResult | null>;
+}
+
+declare const IKeybindingEditingService: ServiceIdentifier<IKeybindingEditingService>;
+interface IKeybindingEditingService {
+    readonly _serviceBrand: undefined;
+    addKeybinding(keybindingItem: ResolvedKeybindingItem, key: string, when: string | undefined): Promise<void>;
+    editKeybinding(keybindingItem: ResolvedKeybindingItem, key: string, when: string | undefined): Promise<void>;
+    removeKeybinding(keybindingItem: ResolvedKeybindingItem): Promise<void>;
+    resetKeybinding(keybindingItem: ResolvedKeybindingItem): Promise<void>;
+}
+
 interface ServiceInitializeParticipant {
     (accessor: ServicesAccessor): Promise<void>;
 }
 declare function registerServiceInitializeParticipant(participant: ServiceInitializeParticipant): void;
-declare const onRenderWorkbench: Event<ServicesAccessor>;
+declare const onRenderWorkbench: Event$1<ServicesAccessor>;
 declare function initialize(overrides: IEditorOverrideServices): Promise<void>;
 
-export { IAudioCueService, IBulkEditService, IClipboardService, ICodeEditorService, IDebugService, IEditorService, IEditorWorkerService, IFileService, IHostService, ILanguageService, ILanguageStatusService, ILogService, IMarkdownString, IModelService, IPaneCompositePartService, IPathService, IProductService, IQuickInputService, ISnippetsService, IUriIdentityService, Severity, initialize, onRenderWorkbench, registerServiceInitializeParticipant };
+export { IAction, IAudioCueService, IBulkEditService, IClipboardService, ICodeEditorService, IColorTheme, ICommandService, IConfigurationChangeEvent, IConfigurationService, IDebugService, IEditorService, IEditorWorkerService, IFileService, IHostService, IInstantiationService, IKeybindingEditingService, ILanguageService, ILanguageStatusService, ILayoutService, ILogService, IMarkdownString, IModelService, IOpenerService, IPaneCompositePartService, IPathService, IPreferencesSearchService, IPreferencesService, IProductService, IQuickInputService, ISnippetsService, IStorageService, ITelemetryService, IThemeService, IUriIdentityService, IWorkbenchEnvironmentService, IWorkspaceContextService, Severity, StorageScope, StorageTarget, initialize, onRenderWorkbench, registerServiceInitializeParticipant };