@codingame/monaco-vscode-api 1.79.11 → 1.79.13

package/dist/hover.d.ts

@@ -0,0 +1,3106 @@
+import { S as ServiceIdentifier, b as SyncDescriptor, c as IConstructorSignature, I as IInstantiationService, B as BrandedService } from './instantiation.js';
+import { a as UriComponents, U as URI } from './uri.js';
+import { d as IEditorOptions, s as IComposite, t as IProgressIndicator, u as IBoundarySashes, m as IMarkdownString, C as ICompositeControl, T as Orientation } from './editorBrowser.js';
+import { c as FileType } from './files.js';
+import { d as ICommandAction, e as ICommandActionTitle, f as Icon, g as ILocalizedString, E as ExtensionIdentifier, h as IEnvironmentService } from './extensions.d2.ts';
+import { E as Event$1, a as IDisposable, D as Disposable, C as CancellationToken, c as Emitter } from './event.js';
+import { ab as SubmenuAction, A as IAction, B as ICommandService, ac as ColorIdentifier, ad as Color, z as IActionRunner, ae as IRunEvent, G as Command } from './colorRegistry.js';
+import { I as IconIdentifier, T as ThemeIcon, a as ThemeColor } from './themables.js';
+import { I as IJSONSchema } from './jsonSchema.js';
+import { b as IWorkspaceFolder, I as IAnyWorkspaceIdentifier, c as IWorkspaceContextService } from './workspace.js';
+import { K as KeyCode, c as KeyCodeChord, R as ResolvedKeybinding, a as IKeybindingService } from './keybinding.js';
+import { a as IContextKeyService, C as ContextKeyExpression } from './contextkey.js';
+import { S as Severity } from './severity.js';
+import { a as IExtensionService } from './extensionsRegistry.js';
+
+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 IKeybindings {
+    primary?: number;
+    secondary?: number[];
+    win?: {
+        primary: number;
+        secondary?: number[];
+    };
+    linux?: {
+        primary: number;
+        secondary?: number[];
+    };
+    mac?: {
+        primary: number;
+        secondary?: number[];
+    };
+}
+
+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>;
+}
+
+/**
+ * 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 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
+}
+
+type IconDefaults = ThemeIcon | IconDefinition;
+interface IconDefinition {
+    font?: IconFontContribution;
+    fontCharacter: string;
+}
+interface IconContribution {
+    readonly id: string;
+    description: string | undefined;
+    deprecationMessage?: string;
+    readonly defaults: IconDefaults;
+}
+declare namespace IconContribution {
+    function getDefinition(contribution: IconContribution, registry: IIconRegistry): IconDefinition | undefined;
+}
+interface IconFontContribution {
+    readonly id: string;
+    readonly definition: IconFontDefinition;
+}
+interface IconFontDefinition {
+    readonly weight?: string;
+    readonly style?: string;
+    readonly src: IconFontSource[];
+}
+declare namespace IconFontDefinition {
+    function toJSONObject(iconFont: IconFontDefinition): any;
+    function fromJSONObject(json: any): IconFontDefinition | 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<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;
+}
+
+interface IPaneComposite extends IComposite {
+    /**
+     * Returns the minimal width needed to avoid any content horizontal truncation
+     */
+    getOptimalWidth(): number | undefined;
+    openView<T extends IView$3>(id: string, focus?: boolean): T | undefined;
+    getViewPaneContainer(): IViewPaneContainer | undefined;
+}
+
+declare const enum ViewContainerLocation {
+    Sidebar = 0,
+    Panel = 1,
+    AuxiliaryBar = 2
+}
+type OpenCommandActionDescriptor = {
+    readonly id: string;
+    readonly title?: ILocalizedString | string;
+    readonly mnemonicTitle?: string;
+    readonly order?: number;
+    readonly keybindings?: IKeybindings & {
+        when?: ContextKeyExpression;
+    };
+};
+/**
+ * View Container Contexts
+ */
+interface IViewContainerDescriptor {
+    /**
+     * The id of the view container
+     */
+    readonly id: string;
+    /**
+     * The title of the view container
+     */
+    readonly title: ILocalizedString | string;
+    /**
+     * Icon representation of the View container
+     */
+    readonly icon?: ThemeIcon | URI;
+    /**
+     * Order of the view container.
+     */
+    readonly order?: number;
+    /**
+     * IViewPaneContainer Ctor to instantiate
+     */
+    readonly ctorDescriptor: SyncDescriptor<IViewPaneContainer>;
+    /**
+     * Descriptor for open view container command
+     * If not provided, view container info (id, title) is used.
+     *
+     * Note: To prevent registering open command, use `doNotRegisterOpenCommand` flag while registering the view container
+     */
+    readonly openCommandActionDescriptor?: OpenCommandActionDescriptor;
+    /**
+     * Storage id to use to store the view container state.
+     * If not provided, it will be derived.
+     */
+    readonly storageId?: string;
+    /**
+     * If enabled, view container is not shown if it has no active views.
+     */
+    readonly hideIfEmpty?: boolean;
+    /**
+     * Id of the extension that contributed the view container
+     */
+    readonly extensionId?: ExtensionIdentifier;
+    readonly alwaysUseContainerInfo?: boolean;
+    readonly viewOrderDelegate?: ViewOrderDelegate;
+    readonly rejectAddedViews?: boolean;
+    requestedIndex?: number;
+}
+interface ViewOrderDelegate {
+    getOrder(group?: string): number | undefined;
+}
+interface ViewContainer extends IViewContainerDescriptor {
+}
+interface IViewDescriptor {
+    readonly type?: string;
+    readonly id: string;
+    readonly name: string;
+    readonly ctorDescriptor: SyncDescriptor<IView$3>;
+    readonly when?: ContextKeyExpression;
+    readonly order?: number;
+    readonly weight?: number;
+    readonly collapsed?: boolean;
+    readonly canToggleVisibility?: boolean;
+    readonly canMoveView?: boolean;
+    readonly containerIcon?: ThemeIcon | URI;
+    readonly containerTitle?: string;
+    readonly hideByDefault?: boolean;
+    readonly workspace?: boolean;
+    readonly focusCommand?: {
+        id: string;
+        keybindings?: IKeybindings;
+    };
+    readonly group?: string;
+    readonly remoteAuthority?: string | string[];
+    readonly virtualWorkspace?: string;
+    readonly openCommandActionDescriptor?: OpenCommandActionDescriptor;
+}
+interface IViewDescriptorRef {
+    viewDescriptor: IViewDescriptor;
+    index: number;
+}
+interface IAddedViewDescriptorRef extends IViewDescriptorRef {
+    collapsed: boolean;
+    size?: number;
+}
+interface IViewContainerModel {
+    readonly viewContainer: ViewContainer;
+    readonly title: string;
+    readonly icon: ThemeIcon | URI | undefined;
+    readonly keybindingId: string | undefined;
+    readonly onDidChangeContainerInfo: Event$1<{
+        title?: boolean;
+        icon?: boolean;
+        keybindingId?: boolean;
+        badgeEnablement?: boolean;
+    }>;
+    readonly allViewDescriptors: ReadonlyArray<IViewDescriptor>;
+    readonly onDidChangeAllViewDescriptors: Event$1<{
+        added: ReadonlyArray<IViewDescriptor>;
+        removed: ReadonlyArray<IViewDescriptor>;
+    }>;
+    readonly activeViewDescriptors: ReadonlyArray<IViewDescriptor>;
+    readonly onDidChangeActiveViewDescriptors: Event$1<{
+        added: ReadonlyArray<IViewDescriptor>;
+        removed: ReadonlyArray<IViewDescriptor>;
+    }>;
+    readonly visibleViewDescriptors: ReadonlyArray<IViewDescriptor>;
+    readonly onDidAddVisibleViewDescriptors: Event$1<IAddedViewDescriptorRef[]>;
+    readonly onDidRemoveVisibleViewDescriptors: Event$1<IViewDescriptorRef[]>;
+    readonly onDidMoveVisibleViewDescriptors: Event$1<{
+        from: IViewDescriptorRef;
+        to: IViewDescriptorRef;
+    }>;
+    isVisible(id: string): boolean;
+    setVisible(id: string, visible: boolean): void;
+    isCollapsed(id: string): boolean;
+    setCollapsed(id: string, collapsed: boolean): void;
+    getSize(id: string): number | undefined;
+    setSizes(newSizes: readonly {
+        id: string;
+        size: number;
+    }[]): void;
+    move(from: string, to: string): void;
+}
+interface IView$3 {
+    readonly id: string;
+    focus(): void;
+    isVisible(): boolean;
+    isBodyVisible(): boolean;
+    setExpanded(expanded: boolean): boolean;
+    getProgressIndicator(): IProgressIndicator | undefined;
+}
+declare const IViewsService: ServiceIdentifier<IViewsService>;
+interface IViewsService {
+    readonly _serviceBrand: undefined;
+    readonly onDidChangeViewContainerVisibility: Event$1<{
+        id: string;
+        visible: boolean;
+        location: ViewContainerLocation;
+    }>;
+    isViewContainerVisible(id: string): boolean;
+    openViewContainer(id: string, focus?: boolean): Promise<IPaneComposite | null>;
+    closeViewContainer(id: string): void;
+    getVisibleViewContainer(location: ViewContainerLocation): ViewContainer | null;
+    getActiveViewPaneContainerWithId(viewContainerId: string): IViewPaneContainer | null;
+    readonly onDidChangeViewVisibility: Event$1<{
+        id: string;
+        visible: boolean;
+    }>;
+    isViewVisible(id: string): boolean;
+    openView<T extends IView$3>(id: string, focus?: boolean): Promise<T | null>;
+    closeView(id: string): void;
+    getActiveViewWithId<T extends IView$3>(id: string): T | null;
+    getViewWithId<T extends IView$3>(id: string): T | null;
+    getViewProgressIndicator(id: string): IProgressIndicator | undefined;
+}
+declare enum ViewVisibilityState {
+    Default = 0,
+    Expand = 1
+}
+declare const IViewDescriptorService: ServiceIdentifier<IViewDescriptorService>;
+interface IViewDescriptorService {
+    readonly _serviceBrand: undefined;
+    readonly viewContainers: ReadonlyArray<ViewContainer>;
+    readonly onDidChangeViewContainers: Event$1<{
+        added: ReadonlyArray<{
+            container: ViewContainer;
+            location: ViewContainerLocation;
+        }>;
+        removed: ReadonlyArray<{
+            container: ViewContainer;
+            location: ViewContainerLocation;
+        }>;
+    }>;
+    getDefaultViewContainer(location: ViewContainerLocation): ViewContainer | undefined;
+    getViewContainerById(id: string): ViewContainer | null;
+    isViewContainerRemovedPermanently(id: string): boolean;
+    getDefaultViewContainerLocation(viewContainer: ViewContainer): ViewContainerLocation | null;
+    getViewContainerLocation(viewContainer: ViewContainer): ViewContainerLocation | null;
+    getViewContainersByLocation(location: ViewContainerLocation): ViewContainer[];
+    getViewContainerModel(viewContainer: ViewContainer): IViewContainerModel;
+    readonly onDidChangeContainerLocation: Event$1<{
+        viewContainer: ViewContainer;
+        from: ViewContainerLocation;
+        to: ViewContainerLocation;
+    }>;
+    moveViewContainerToLocation(viewContainer: ViewContainer, location: ViewContainerLocation, requestedIndex?: number): void;
+    getViewContainerBadgeEnablementState(id: string): boolean;
+    setViewContainerBadgeEnablementState(id: string, badgesEnabled: boolean): void;
+    getViewDescriptorById(id: string): IViewDescriptor | null;
+    getViewContainerByViewId(id: string): ViewContainer | null;
+    getDefaultContainerById(id: string): ViewContainer | null;
+    getViewLocationById(id: string): ViewContainerLocation | null;
+    readonly onDidChangeContainer: Event$1<{
+        views: IViewDescriptor[];
+        from: ViewContainer;
+        to: ViewContainer;
+    }>;
+    moveViewsToContainer(views: IViewDescriptor[], viewContainer: ViewContainer, visibilityState?: ViewVisibilityState): void;
+    readonly onDidChangeLocation: Event$1<{
+        views: IViewDescriptor[];
+        from: ViewContainerLocation;
+        to: ViewContainerLocation;
+    }>;
+    moveViewToLocation(view: IViewDescriptor, location: ViewContainerLocation): void;
+    reset(): void;
+}
+interface IEditableData {
+    validationMessage: (value: string) => {
+        content: string;
+        severity: Severity;
+    } | null;
+    placeholder?: string | null;
+    startingValue?: string | null;
+    onFinish: (value: string, success: boolean) => Promise<void>;
+}
+interface IViewPaneContainer {
+    onDidAddViews: Event$1<IView$3[]>;
+    onDidRemoveViews: Event$1<IView$3[]>;
+    onDidChangeViewVisibility: Event$1<IView$3>;
+    readonly views: IView$3[];
+    setVisible(visible: boolean): void;
+    isVisible(): boolean;
+    focus(): void;
+    getActionsContext(): unknown;
+    getView(viewId: string): IView$3 | undefined;
+    toggleViewVisibility(viewId: string): void;
+}
+
+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[] | undefined;
+    readonly filesToDiff?: IPath[] | undefined;
+    readonly filesToMerge?: IPath[] | 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>;
+}
+
+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;
+}
+
+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 {
+    /**
+     * Generic top offset
+     */
+    readonly top: number;
+    /**
+     * Quick pick specific top offset.
+     */
+    readonly quickPickTop: number;
+}
+
+declare const ILayoutService: ServiceIdentifier<ILayoutService>;
+interface ILayoutService {
+    readonly _serviceBrand: undefined;
+    /**
+     * The dimensions of the container.
+     */
+    readonly dimension: IDimension;
+    /**
+     * Does the application have a single container?
+     */
+    readonly hasContainer: boolean;
+    /**
+     * 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.
+     *
+     */
+    readonly container: HTMLElement;
+    /**
+     * An offset to use for positioning elements inside the container.
+     */
+    readonly offset: ILayoutOffsetInfo;
+    /**
+     * An event that is emitted when the container is layed out. The
+     * event carries the dimensions of the container as part of it.
+     */
+    readonly onDidLayout: Event$1<IDimension>;
+    /**
+     * 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$1 {
+    label: string;
+    commandId: string;
+    iconClass?: string;
+    run(target: HTMLElement): void;
+}
+interface IUpdatableHoverOptions {
+    actions?: IHoverAction$1[];
+    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$1 | undefined;
+    onDidHideHover?: () => void;
+    delay: number;
+    placement?: 'mouse' | 'element';
+}
+interface IHoverWidget$1 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;
+}
+declare const enum ActionsOrientation {
+    HORIZONTAL = 0,
+    VERTICAL = 1
+}
+interface ActionTrigger {
+    keys?: KeyCode[];
+    keyDown: boolean;
+}
+interface IActionBarOptions {
+    readonly orientation?: ActionsOrientation;
+    readonly context?: unknown;
+    readonly actionViewItemProvider?: IActionViewItemProvider;
+    readonly actionRunner?: IActionRunner;
+    readonly ariaLabel?: string;
+    readonly ariaRole?: string;
+    readonly animated?: boolean;
+    readonly triggerKeys?: ActionTrigger;
+    readonly allowContextMenu?: boolean;
+    readonly preventLoopNavigation?: boolean;
+    readonly focusOnlyEnabledItems?: boolean;
+    readonly hoverDelegate?: IHoverDelegate;
+}
+interface IActionOptions extends IActionViewItemOptions {
+    index?: number;
+}
+declare class ActionBar extends Disposable implements IActionRunner {
+    private readonly options;
+    private _actionRunner;
+    private readonly _actionRunnerDisposables;
+    private _context;
+    private readonly _orientation;
+    private readonly _triggerKeys;
+    viewItems: IActionViewItem[];
+    private readonly viewItemDisposables;
+    private previouslyFocusedItem?;
+    protected focusedItem?: number;
+    private focusTracker;
+    private triggerKeyDown;
+    private focusable;
+    domNode: HTMLElement;
+    protected readonly actionsList: HTMLElement;
+    private readonly _onDidBlur;
+    readonly onDidBlur: Event$1<void>;
+    private readonly _onDidCancel;
+    readonly onDidCancel: Event$1<void>;
+    private cancelHasListener;
+    private readonly _onDidRun;
+    readonly onDidRun: Event$1<IRunEvent>;
+    private readonly _onWillRun;
+    readonly onWillRun: Event$1<IRunEvent>;
+    constructor(container: HTMLElement, options?: IActionBarOptions);
+    private refreshRole;
+    setAriaLabel(label: string): void;
+    setFocusable(focusable: boolean): void;
+    private isTriggerKeyEvent;
+    private updateFocusedItem;
+    get context(): unknown;
+    set context(context: unknown);
+    get actionRunner(): IActionRunner;
+    set actionRunner(actionRunner: IActionRunner);
+    getContainer(): HTMLElement;
+    hasAction(action: IAction): boolean;
+    getAction(indexOrElement: number | HTMLElement): IAction | undefined;
+    push(arg: IAction | ReadonlyArray<IAction>, options?: IActionOptions): void;
+    getWidth(index: number): number;
+    getHeight(index: number): number;
+    pull(index: number): void;
+    clear(): void;
+    length(): number;
+    isEmpty(): boolean;
+    focus(index?: number): void;
+    focus(selectFirst?: boolean): void;
+    private focusFirst;
+    private focusLast;
+    protected focusNext(forceLoop?: boolean): boolean;
+    protected focusPrevious(forceLoop?: boolean): boolean;
+    protected updateFocus(fromRight?: boolean, preventScroll?: boolean, forceFocus?: boolean): void;
+    private doTrigger;
+    run(action: IAction, context?: unknown): Promise<void>;
+    dispose(): void;
+}
+
+/**
+ * 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;
+}
+declare abstract class CompositeRegistry<T extends Composite> extends Disposable {
+    private readonly _onDidRegister;
+    readonly onDidRegister: Event$1<CompositeDescriptor<T>>;
+    private readonly _onDidDeregister;
+    readonly onDidDeregister: Event$1<CompositeDescriptor<T>>;
+    private readonly composites;
+    protected registerComposite(descriptor: CompositeDescriptor<T>): void;
+    protected deregisterComposite(id: string): void;
+    getComposite(id: string): CompositeDescriptor<T> | undefined;
+    protected getComposites(): CompositeDescriptor<T>[];
+    private compositeById;
+}
+
+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;
+}
+interface IContextMenuProvider {
+    showContextMenu(delegate: IContextMenuDelegate): void;
+}
+
+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 IActivity {
+    readonly badge: IBadge;
+    readonly clazz?: string;
+    readonly priority?: number;
+}
+declare const IActivityService: ServiceIdentifier<IActivityService>;
+interface IActivityService {
+    readonly _serviceBrand: undefined;
+    /**
+     * Show activity for the given view container
+     */
+    showViewContainerActivity(viewContainerId: string, badge: IActivity): IDisposable;
+    /**
+     * Show activity for the given view
+     */
+    showViewActivity(viewId: string, badge: IActivity): IDisposable;
+    /**
+     * Show accounts activity
+     */
+    showAccountsActivity(activity: IActivity): IDisposable;
+    /**
+     * Show global activity
+     */
+    showGlobalActivity(activity: IActivity): IDisposable;
+}
+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;
+    /**
+     * Return the last active viewlet id.
+     */
+    getLastActivePaneCompositeId(viewContainerLocation: ViewContainerLocation): string;
+    /**
+     * Show an activity in a viewlet.
+     */
+    showActivity(id: string, viewContainerLocation: ViewContainerLocation, badge: IBadge, clazz?: string, priority?: number): IDisposable;
+}
+
+declare const IStatusbarService: ServiceIdentifier<IStatusbarService>;
+interface IStatusbarService {
+    readonly _serviceBrand: undefined;
+    /**
+     * An event that is triggered when an entry's visibility is changed.
+     */
+    readonly onDidChangeEntryVisibility: Event$1<{
+        id: string;
+        visible: boolean;
+    }>;
+    /**
+     * Adds an entry to the statusbar with the given alignment and priority. Use the returned accessor
+     * to update or remove the statusbar entry.
+     *
+     * @param id identifier of the entry is needed to allow users to hide entries via settings
+     * @param alignment either LEFT or RIGHT side in the status bar
+     * @param priority items get arranged from highest priority to lowest priority from left to right
+     * in their respective alignment slot
+     */
+    addEntry(entry: IStatusbarEntry, id: string, alignment: StatusbarAlignment, priority?: number | IStatusbarEntryPriority): IStatusbarEntryAccessor;
+    /**
+     * Adds an entry to the statusbar with the given alignment relative to another entry. Use the returned
+     * accessor to update or remove the statusbar entry.
+     *
+     * @param id identifier of the entry is needed to allow users to hide entries via settings
+     * @param alignment either LEFT or RIGHT side in the status bar
+     * @param location a reference to another entry to position relative to
+     */
+    addEntry(entry: IStatusbarEntry, id: string, alignment: StatusbarAlignment, location?: IStatusbarEntryLocation): IStatusbarEntryAccessor;
+    /**
+     * Return if an entry is visible or not.
+     */
+    isEntryVisible(id: string): boolean;
+    /**
+     * Allows to update an entry's visibility with the provided ID.
+     */
+    updateEntryVisibility(id: string, visible: boolean): void;
+    /**
+     * Focused the status bar. If one of the status bar entries was focused, focuses it directly.
+     */
+    focus(preserveEntryFocus?: boolean): void;
+    /**
+     * Focuses the next status bar entry. If none focused, focuses the first.
+     */
+    focusNextEntry(): void;
+    /**
+     * Focuses the previous status bar entry. If none focused, focuses the last.
+     */
+    focusPreviousEntry(): void;
+    /**
+     *	Returns true if a status bar entry is focused.
+     */
+    isEntryFocused(): boolean;
+    /**
+     * Temporarily override statusbar style.
+     */
+    overrideStyle(style: IStatusbarStyleOverride): IDisposable;
+}
+declare const enum StatusbarAlignment {
+    LEFT = 0,
+    RIGHT = 1
+}
+interface IStatusbarEntryLocation {
+    /**
+     * The identifier of another status bar entry to
+     * position relative to.
+     */
+    id: string;
+    /**
+     * The alignment of the status bar entry relative
+     * to the referenced entry.
+     */
+    alignment: StatusbarAlignment;
+    /**
+     * Whether to move the entry close to the location
+     * so that it appears as if both this entry and
+     * the location belong to each other.
+     */
+    compact?: boolean;
+}
+interface IStatusbarEntryPriority {
+    /**
+     * The main priority of the entry that
+     * defines the order of appearance:
+     * either a number or a reference to
+     * another status bar entry to position
+     * relative to.
+     *
+     * May not be unique across all entries.
+     */
+    readonly primary: number | IStatusbarEntryLocation;
+    /**
+     * The secondary priority of the entry
+     * is used in case the main priority
+     * matches another one's priority.
+     *
+     * Should be unique across all entries.
+     */
+    readonly secondary: number;
+}
+declare const ShowTooltipCommand: Command;
+interface IStatusbarStyleOverride {
+    readonly priority: number;
+    readonly foreground?: ColorIdentifier;
+    readonly background?: ColorIdentifier;
+    readonly border?: ColorIdentifier;
+}
+/**
+ * A declarative way of describing a status bar entry
+ */
+interface IStatusbarEntry {
+    /**
+     * The (short) name to show for the entry like 'Language Indicator',
+     * 'Git Status' etc.
+     */
+    readonly name: string;
+    /**
+     * The text to show for the entry. You can embed icons in the text by leveraging the syntax:
+     *
+     * `My text $(icon name) contains icons like $(icon name) this one.`
+     */
+    readonly text: string;
+    /**
+     * Text to be read out by the screen reader.
+     */
+    readonly ariaLabel: string;
+    /**
+     * Role of the status bar entry which defines how a screen reader interacts with it.
+     * Default is 'button'.
+     */
+    readonly role?: string;
+    /**
+     * An optional tooltip text to show when you hover over the entry
+     */
+    readonly tooltip?: string | IMarkdownString | HTMLElement;
+    /**
+     * An optional color to use for the entry
+     */
+    readonly color?: string | ThemeColor;
+    /**
+     * An optional background color to use for the entry
+     */
+    readonly backgroundColor?: string | ThemeColor;
+    /**
+     * An optional command to execute on click.
+     *
+     * Can use the special `ShowTooltipCommand` to
+     * show the tooltip on click if provided.
+     */
+    readonly command?: string | Command | typeof ShowTooltipCommand;
+    /**
+     * Whether to show a beak above the status bar entry.
+     */
+    readonly showBeak?: boolean;
+    /**
+     * Will enable a spinning icon in front of the text to indicate progress. When `true` is
+     * specified, `syncing` will be used.
+     */
+    readonly showProgress?: boolean | 'syncing' | 'loading';
+}
+interface IStatusbarEntryAccessor extends IDisposable {
+    /**
+     * Allows to update an existing status bar entry.
+     */
+    update(properties: IStatusbarEntry): void;
+}
+
+declare const IHoverService: ServiceIdentifier<IHoverService>;
+/**
+ * Enables the convenient display of rich markdown-based hovers in the workbench.
+ */
+interface IHoverService {
+    readonly _serviceBrand: undefined;
+    /**
+     * Shows a hover, provided a hover with the same options object is not already visible.
+     * @param options A set of options defining the characteristics of the hover.
+     * @param focus Whether to focus the hover (useful for keyboard accessibility).
+     *
+     * **Example:** A simple usage with a single element target.
+     *
+     * ```typescript
+     * showHover({
+     *   text: new MarkdownString('Hello world'),
+     *   target: someElement
+     * });
+     * ```
+     */
+    showHover(options: IHoverOptions, focus?: boolean): IHoverWidget | undefined;
+    /**
+     * Hides the hover if it was visible. This call will be ignored if the the hover is currently
+     * "locked" via the alt/option key.
+     */
+    hideHover(): void;
+}
+interface IHoverWidget extends IDisposable {
+    readonly isDisposed: boolean;
+}
+interface IHoverOptions {
+    /**
+     * 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 IHoverTarget for more complex cases where multiple elements and/or a
+     * dispose method is required.
+     */
+    target: IHoverTarget | HTMLElement;
+    /**
+     * An ID to associate with the hover to be used as an equality check. Normally when calling
+     * {@link IHoverService.showHover} the options object itself is used to determine if the hover
+     * is the same one that is already showing, when this is set, the ID will be used instead.
+     */
+    id?: number | string;
+    /**
+     * A set of actions for the hover's "status bar".
+     */
+    actions?: IHoverAction[];
+    /**
+     * An optional array of classes to add to the hover element.
+     */
+    additionalClasses?: string[];
+    /**
+     * An optional link handler for markdown links, if this is not provided the IOpenerService will
+     * be used to open the links using its default options.
+     */
+    linkHandler?(url: string): void;
+    /**
+     * Whether to hide the hover when the mouse leaves the `target` and enters the actual hover.
+     * This is false by default when text is an `IMarkdownString` and true when `text` is a
+     * `string`. Note that this will be ignored if any `actions` are provided as hovering is
+     * required to make them accessible.
+     *
+     * In general hiding on hover is desired for:
+     * - Regular text where selection is not important
+     * - Markdown that contains no links where selection is not important
+     */
+    hideOnHover?: boolean;
+    /**
+     * When {@link hideOnHover} is explicitly true or undefined and its auto value is detected to
+     * hide, show a hint at the bottom of the hover explaining how to mouse over the widget. This
+     * should be used in the cases where despite the hover having no interactive content, it's
+     * likely the user may want to interact with it somehow.
+     */
+    showHoverHint?: boolean;
+    /**
+     * Whether to hide the hover when a key is pressed.
+     */
+    hideOnKeyDown?: boolean;
+    /**
+     * 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;
+    /**
+     * Force the hover position, reducing the size of the hover instead of adjusting the hover
+     * position.
+     */
+    forcePosition?: boolean;
+    /**
+     * Whether to show the hover pointer
+     */
+    showPointer?: boolean;
+    /**
+     * Whether to show a compact hover
+     */
+    compact?: 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;
+    /**
+     * Whether to trap focus in the following ways:
+     * - When the hover closes, focus goes to the element that had focus before the hover opened
+     * - If there are elements in the hover to focus, focus stays inside of the hover when tabbing
+     */
+    trapFocus?: boolean;
+    container?: HTMLElement;
+}
+interface IHoverAction {
+    /**
+     * The label to use in the hover's status bar.
+     */
+    label: string;
+    /**
+     * The command ID of the action, this is used to resolve the keybinding to display after the
+     * action label.
+     */
+    commandId: string;
+    /**
+     * An optional class of an icon that will be displayed before the label.
+     */
+    iconClass?: string;
+    /**
+     * The callback to run the action.
+     * @param target The action element that was activated.
+     */
+    run(target: HTMLElement): void;
+}
+/**
+ * A target for a hover.
+ */
+interface IHoverTarget extends IDisposable {
+    /**
+     * A set of target elements used to position the hover. If multiple elements are used the hover
+     * will try to not overlap any target element. An example use case for this is show a hover for
+     * wrapped text.
+     */
+    readonly targetElements: readonly HTMLElement[];
+    /**
+     * An optional absolute x coordinate to position the hover with, for example to position the
+     * hover using `MouseEvent.pageX`.
+     */
+    x?: number;
+    /**
+     * An optional absolute y coordinate to position the hover with, for example to position the
+     * hover using `MouseEvent.pageY`.
+     */
+    y?: number;
+}
+
+export { StorageScope as $, ActionBar as A, IHoverOptions as B, Composite as C, IHoverWidget as D, Dimension as E, Parts as F, IStatusbarService as G, HoverPosition as H, IContextMenuProvider as I, IStatusbarEntry as J, IStatusbarEntryLocation as K, LayoutPriority as L, MenuId as M, IStatusbarEntryPriority as N, IStatusbarEntryAccessor as O, Part as P, IStatusbarStyleOverride as Q, ConfigurationTarget as R, StatusbarAlignment as S, ITelemetryEndpoint as T, IOpenEmptyWindowOptions as U, ViewContainerLocation as V, IWindowOpenable as W, IOpenWindowOptions as X, IEditableData as Y, IConfigurationChangeEvent as Z, IColorTheme as _, ActionsOrientation as a, StorageTarget as a0, IOpenerService as a1, IViewsService as a2, ILayoutService as a3, IActionViewItemProvider as b, AnchorAlignment as c, IMenuService as d, IContextMenuService as e, ITelemetryService as f, IMenuActionOptions as g, IStorageService as h, CompositeRegistry as i, IWorkbenchLayoutService as j, IThemeService as k, IPartOptions as l, IActionViewItem as m, IView as n, IPaneComposite as o, PaneCompositeDescriptor as p, IBadge as q, PaneComposite as r, IViewDescriptorService as s, IActivityService as t, IPaneCompositePartService as u, IActivity as v, IConfigurationService as w, IWorkbenchEnvironmentService as x, IHoverService as y, IContextViewService as z };