@codingame/monaco-vscode-api 1.79.11 → 1.79.13

package/dist/monaco.d.ts

@@ -1,21 +1,21 @@
 import * as monaco from 'monaco-editor';
 import { I as IEditorOverrideServices } from './standaloneServices.js';
 import { E as Event, D as Disposable, a as IDisposable, I as IReference } from './event.js';
-export { c as DisposableStore } from './event.js';
-import { q as ITextModel, r as IModelDecorationOptions, s as IModelDecorationsChangeAccessor, t as IEditorContribution, b as ICodeEditor, u as IPosition } from './editorBrowser.js';
-import { L as LanguageFeatureRegistry, I as ILanguageFeaturesService, F as FoldingRangeProvider, a as ILanguageConfigurationService, b as INotificationService, c as ITextFileEditorModel } from './languageFeatures.js';
-export { C as CommandsRegistry, r as registerColor } from './languageFeatures.js';
+export { b as DisposableStore } from './event.js';
+import { j as ITextModel, o as IModelDecorationOptions, p as IModelDecorationsChangeAccessor, q as IEditorContribution, b as ICodeEditor, l as IPosition } from './editorBrowser.js';
+import { F as FoldingRangeProvider, I as INotificationService } from './colorRegistry.js';
+export { C as CommandsRegistry, r as registerColor } from './colorRegistry.js';
+import { L as LanguageFeatureRegistry, I as ILanguageFeaturesService, a as ILanguageConfigurationService } from './languageFeatures.js';
 import { a as IContextKeyService } from './contextkey.js';
 import { S as ServiceIdentifier } from './instantiation.js';
 import { I as IJSONSchema } from './jsonSchema.js';
 import { U as URI } from './uri.js';
 import { f as IFileDeleteOptions } from './files.js';
+import { q as ITextFileEditorModel } from './editor.js';
 import 'vscode';
 import './themables.js';
-import './severity.js';
-import './editor.js';
-import './progress.js';
 import './extensions.d2.ts';
+import './severity.js';
 
 interface ErrorListenerCallback {
     (error: any): void;

package/dist/service-override/editor.d.ts

@@ -12,6 +12,7 @@ import '../instantiation.js';
 import 'monaco-editor';
 import '../themables.js';
 import '../contextkey.js';
+import '../files.js';
 import '../severity.js';
 
 declare class SimpleEditorService extends Disposable implements IEditorService {

package/dist/service-override/views.d.ts

@@ -1,17 +1,522 @@
-import { a as ServicesAccessor } from '../instantiation.js';
-import { a as IDisposable } from '../event.js';
+import { I as IInstantiationService, a as ServicesAccessor } from '../instantiation.js';
+import { D as Disposable, E as Event, c as Emitter, a as IDisposable } from '../event.js';
 export { I as IReference } from '../event.js';
 import { I as IEditorOverrideServices } from '../standaloneServices.js';
-import { V as ViewContainerLocation } from '../views.js';
+import { A as ActionBar, I as IContextMenuProvider, a as ActionsOrientation, b as IActionViewItemProvider, c as AnchorAlignment, d as IMenuService, e as IContextMenuService, f as ITelemetryService, M as MenuId, g as IMenuActionOptions, C as Composite, P as Part, h as IStorageService, i as CompositeRegistry, j as IWorkbenchLayoutService, k as IThemeService, l as IPartOptions, m as IActionViewItem, n as IView, o as IPaneComposite, p as PaneCompositeDescriptor, q as IBadge, r as PaneComposite, L as LayoutPriority, s as IViewDescriptorService, t as IActivityService, u as IPaneCompositePartService, v as IActivity, w as IConfigurationService, x as IWorkbenchEnvironmentService, y as IHoverService, z as IContextViewService, B as IHoverOptions, D as IHoverWidget, H as HoverPosition, E as Dimension, F as Parts, V as ViewContainerLocation, G as IStatusbarService, J as IStatusbarEntry, S as StatusbarAlignment, K as IStatusbarEntryLocation, N as IStatusbarEntryPriority, O as IStatusbarEntryAccessor, Q as IStatusbarStyleOverride } from '../hover.js';
+import { a as IContextKeyService, b as IContextKey } from '../contextkey.js';
+import { z as IActionRunner, A as IAction, I as INotificationService, B as ICommandService } from '../colorRegistry.js';
+import { s as IComposite, t as IProgressIndicator, u as IBoundarySashes } from '../editorBrowser.js';
 export { d as IEditorOptions, h as IResolvedTextEditorModel } from '../editorBrowser.js';
+import { R as ResolvedKeybinding, a as IKeybindingService } from '../keybinding.js';
 import { T as ThemeIcon } from '../themables.js';
+import { a as IExtensionService } from '../extensionsRegistry.js';
+import { c as IWorkspaceContextService } from '../workspace.js';
 import { O as OpenEditor } from '../editor.d2.ts';
 import 'vscode';
 import 'monaco-editor';
 import '../uri.js';
-import '../contextkey.js';
+import '../files.js';
 import '../extensions.d2.ts';
-import '../progress.js';
+import '../jsonSchema.js';
+import '../severity.js';
+
+interface IToolBarOptions {
+    orientation?: ActionsOrientation;
+    actionViewItemProvider?: IActionViewItemProvider;
+    ariaLabel?: string;
+    getKeyBinding?: (action: IAction) => ResolvedKeybinding | undefined;
+    actionRunner?: IActionRunner;
+    toggleMenuTitle?: string;
+    anchorAlignmentProvider?: () => AnchorAlignment;
+    renderDropdownAsChildElement?: boolean;
+    moreIcon?: ThemeIcon;
+    allowContextMenu?: boolean;
+}
+/**
+ * A widget that combines an action bar for primary actions and a dropdown for secondary actions.
+ */
+declare class ToolBar extends Disposable {
+    private options;
+    protected readonly actionBar: ActionBar;
+    private toggleMenuAction;
+    private toggleMenuActionViewItem;
+    private submenuActionViewItems;
+    private hasSecondaryActions;
+    private readonly lookupKeybindings;
+    private readonly element;
+    private _onDidChangeDropdownVisibility;
+    readonly onDidChangeDropdownVisibility: Event<boolean>;
+    private disposables;
+    constructor(container: HTMLElement, contextMenuProvider: IContextMenuProvider, options?: IToolBarOptions);
+    set actionRunner(actionRunner: IActionRunner);
+    get actionRunner(): IActionRunner;
+    set context(context: unknown);
+    getElement(): HTMLElement;
+    focus(): void;
+    getItemsWidth(): number;
+    getItemAction(indexOrElement: number | HTMLElement): IAction | undefined;
+    getItemWidth(index: number): number;
+    getItemsLength(): number;
+    setAriaLabel(label: string): void;
+    setActions(primaryActions: ReadonlyArray<IAction>, secondaryActions?: ReadonlyArray<IAction>): void;
+    isEmpty(): boolean;
+    private getKeybindingLabel;
+    private clear;
+    dispose(): void;
+}
+
+declare const enum HiddenItemStrategy {
+    /** This toolbar doesn't support hiding*/
+    NoHide = -1,
+    /** Hidden items aren't shown anywhere */
+    Ignore = 0,
+    /** Hidden items move into the secondary group */
+    RenderInSecondaryGroup = 1
+}
+type IWorkbenchToolBarOptions = IToolBarOptions & {
+    /**
+     * Items of the primary group can be hidden. When this happens the item can
+     * - move into the secondary popup-menu, or
+     * - not be shown at all
+     */
+    hiddenItemStrategy?: HiddenItemStrategy;
+    /**
+     * Optional menu id which is used for a "Reset Menu" command. This should be the
+     * menu id that defines the contents of this workbench menu
+     */
+    resetMenu?: MenuId;
+    /**
+     * Optional menu id which items are used for the context menu of the toolbar.
+     */
+    contextMenu?: MenuId;
+    /**
+     * Optional options how menu actions are created and invoked
+     */
+    menuOptions?: IMenuActionOptions;
+    /**
+     * When set the `workbenchActionExecuted` is automatically send for each invoked action. The `from` property
+     * of the event will the passed `telemetrySource`-value
+     */
+    telemetrySource?: string;
+    /** This is controlled by the WorkbenchToolBar */
+    allowContextMenu?: never;
+    /**
+     * Maximun number of items that can shown. Extra items will be shown in the overflow menu.
+     */
+    maxNumberOfItems?: number;
+};
+/**
+ * The `WorkbenchToolBar` does
+ * - support hiding of menu items
+ * - lookup keybindings for each actions automatically
+ * - send `workbenchActionExecuted`-events for each action
+ *
+ * See {@link MenuWorkbenchToolBar} for a toolbar that is backed by a menu.
+ */
+declare class WorkbenchToolBar extends ToolBar {
+    private _options;
+    private readonly _menuService;
+    private readonly _contextKeyService;
+    private readonly _contextMenuService;
+    private readonly _sessionDisposables;
+    constructor(container: HTMLElement, _options: IWorkbenchToolBarOptions | undefined, _menuService: IMenuService, _contextKeyService: IContextKeyService, _contextMenuService: IContextMenuService, keybindingService: IKeybindingService, telemetryService: ITelemetryService);
+    setActions(_primary: readonly IAction[], _secondary?: readonly IAction[], menuIds?: readonly MenuId[]): void;
+}
+
+interface ICompositeTitleLabel {
+    /**
+     * Asks to update the title for the composite with the given ID.
+     */
+    updateTitle(id: string, title: string, keybinding?: string): void;
+    /**
+     * Called when theming information changes.
+     */
+    updateStyles(): void;
+}
+declare abstract class CompositePart<T extends Composite> extends Part {
+    private readonly notificationService;
+    protected readonly storageService: IStorageService;
+    private readonly telemetryService;
+    protected readonly contextMenuService: IContextMenuService;
+    protected readonly keybindingService: IKeybindingService;
+    protected readonly instantiationService: IInstantiationService;
+    protected readonly registry: CompositeRegistry<T>;
+    private readonly activeCompositeSettingsKey;
+    private readonly defaultCompositeId;
+    private readonly nameForTelemetry;
+    private readonly compositeCSSClass;
+    private readonly titleForegroundColor;
+    protected readonly onDidCompositeOpen: Emitter<{
+        composite: IComposite;
+        focus: boolean;
+    }>;
+    protected readonly onDidCompositeClose: Emitter<IComposite>;
+    protected toolBar: WorkbenchToolBar | undefined;
+    protected titleLabelElement: HTMLElement | undefined;
+    private readonly mapCompositeToCompositeContainer;
+    private readonly mapActionsBindingToComposite;
+    private activeComposite;
+    private lastActiveCompositeId;
+    private readonly instantiatedCompositeItems;
+    private titleLabel;
+    private progressBar;
+    private contentAreaSize;
+    private readonly telemetryActionsListener;
+    private currentCompositeOpenToken;
+    private boundarySashes;
+    constructor(notificationService: INotificationService, storageService: IStorageService, telemetryService: ITelemetryService, contextMenuService: IContextMenuService, layoutService: IWorkbenchLayoutService, keybindingService: IKeybindingService, instantiationService: IInstantiationService, themeService: IThemeService, registry: CompositeRegistry<T>, activeCompositeSettingsKey: string, defaultCompositeId: string, nameForTelemetry: string, compositeCSSClass: string, titleForegroundColor: string | undefined, id: string, options: IPartOptions);
+    protected openComposite(id: string, focus?: boolean): Composite | undefined;
+    private doOpenComposite;
+    protected createComposite(id: string, isActive?: boolean): Composite;
+    protected showComposite(composite: Composite): void;
+    protected onTitleAreaUpdate(compositeId: string): void;
+    private updateTitle;
+    private collectCompositeActions;
+    protected getActiveComposite(): IComposite | undefined;
+    protected getLastActiveCompositeId(): string;
+    protected hideActiveComposite(): Composite | undefined;
+    protected createTitleArea(parent: HTMLElement): HTMLElement;
+    protected createTitleLabel(parent: HTMLElement): ICompositeTitleLabel;
+    updateStyles(): void;
+    protected actionViewItemProvider(action: IAction): IActionViewItem | undefined;
+    protected actionsContextProvider(): unknown;
+    protected createContentArea(parent: HTMLElement): HTMLElement;
+    getProgressIndicator(id: string): IProgressIndicator | undefined;
+    protected getTitleAreaDropDownAnchorAlignment(): AnchorAlignment;
+    layout(width: number, height: number, top: number, left: number): void;
+    setBoundarySashes?(sashes: IBoundarySashes): void;
+    protected removeComposite(compositeId: string): boolean;
+    dispose(): void;
+}
+
+interface IPaneCompositePart extends IView {
+    readonly onDidPaneCompositeOpen: Event<IPaneComposite>;
+    readonly onDidPaneCompositeClose: Event<IPaneComposite>;
+    /**
+     * Opens a viewlet with the given identifier and pass keyboard focus to it if specified.
+     */
+    openPaneComposite(id: string | undefined, focus?: boolean): Promise<IPaneComposite | undefined>;
+    /**
+     * Returns the current active viewlet if any.
+     */
+    getActivePaneComposite(): IPaneComposite | undefined;
+    /**
+     * Returns the viewlet by id.
+     */
+    getPaneComposite(id: string): PaneCompositeDescriptor | undefined;
+    /**
+     * Returns all enabled viewlets
+     */
+    getPaneComposites(): PaneCompositeDescriptor[];
+    /**
+     * Returns the progress indicator for the side bar.
+     */
+    getProgressIndicator(id: string): IProgressIndicator | undefined;
+    /**
+     * Hide the active viewlet.
+     */
+    hideActivePaneComposite(): void;
+    /**
+     * Return the last active viewlet id.
+     */
+    getLastActivePaneCompositeId(): string;
+}
+interface IPaneCompositeSelectorPart {
+    /**
+     * Returns id of pinned view containers following the visual order.
+     */
+    getPinnedPaneCompositeIds(): string[];
+    /**
+     * Returns id of visible view containers following the visual order.
+     */
+    getVisiblePaneCompositeIds(): string[];
+    /**
+     * Show an activity in a viewlet.
+     */
+    showActivity(id: string, badge: IBadge, clazz?: string, priority?: number): IDisposable;
+}
+
+declare class SidebarPart extends CompositePart<PaneComposite> implements IPaneCompositePart {
+    private readonly viewDescriptorService;
+    private readonly contextKeyService;
+    private readonly extensionService;
+    readonly _serviceBrand: undefined;
+    static readonly activeViewletSettingsKey = "workbench.sidebar.activeviewletid";
+    readonly minimumWidth: number;
+    readonly maximumWidth: number;
+    readonly minimumHeight: number;
+    readonly maximumHeight: number;
+    readonly priority: LayoutPriority;
+    readonly snap = true;
+    get preferredWidth(): number | undefined;
+    get onDidPaneCompositeRegister(): Event<PaneCompositeDescriptor>;
+    private _onDidViewletDeregister;
+    readonly onDidPaneCompositeDeregister: Event<PaneCompositeDescriptor>;
+    get onDidPaneCompositeOpen(): Event<IPaneComposite>;
+    get onDidPaneCompositeClose(): Event<IPaneComposite>;
+    private readonly viewletRegistry;
+    private readonly sideBarFocusContextKey;
+    private readonly activeViewletContextKey;
+    private blockOpeningViewlet;
+    constructor(notificationService: INotificationService, storageService: IStorageService, telemetryService: ITelemetryService, contextMenuService: IContextMenuService, layoutService: IWorkbenchLayoutService, keybindingService: IKeybindingService, instantiationService: IInstantiationService, themeService: IThemeService, viewDescriptorService: IViewDescriptorService, contextKeyService: IContextKeyService, extensionService: IExtensionService);
+    private registerListeners;
+    create(parent: HTMLElement): void;
+    protected createTitleArea(parent: HTMLElement): HTMLElement;
+    updateStyles(): void;
+    layout(width: number, height: number, top: number, left: number): void;
+    getActivePaneComposite(): IPaneComposite | undefined;
+    getLastActivePaneCompositeId(): string;
+    hideActivePaneComposite(): void;
+    openPaneComposite(id: string | undefined, focus?: boolean): Promise<IPaneComposite | undefined>;
+    getPaneComposites(): PaneCompositeDescriptor[];
+    getPaneComposite(id: string): PaneCompositeDescriptor;
+    private doOpenViewlet;
+    protected getTitleAreaDropDownAnchorAlignment(): AnchorAlignment;
+    private onTitleAreaContextMenu;
+    toJSON(): object;
+}
+
+declare class ActivityService implements IActivityService {
+    private readonly paneCompositeService;
+    private readonly viewDescriptorService;
+    private readonly instantiationService;
+    _serviceBrand: undefined;
+    private viewActivities;
+    constructor(paneCompositeService: IPaneCompositePartService, viewDescriptorService: IViewDescriptorService, instantiationService: IInstantiationService);
+    showViewContainerActivity(viewContainerId: string, { badge, clazz, priority }: IActivity): IDisposable;
+    showViewActivity(viewId: string, activity: IActivity): IDisposable;
+    showAccountsActivity({ badge, clazz, priority }: IActivity): IDisposable;
+    showGlobalActivity({ badge, clazz, priority }: IActivity): IDisposable;
+}
+
+declare class ActivitybarPart extends Part implements IPaneCompositeSelectorPart {
+    private readonly paneCompositePart;
+    private readonly instantiationService;
+    private readonly storageService;
+    private readonly extensionService;
+    private readonly viewDescriptorService;
+    private readonly contextKeyService;
+    private readonly configurationService;
+    private readonly environmentService;
+    readonly _serviceBrand: undefined;
+    private static readonly PINNED_VIEW_CONTAINERS;
+    private static readonly PLACEHOLDER_VIEW_CONTAINERS;
+    private static readonly ACTION_HEIGHT;
+    private static readonly ACCOUNTS_ACTION_INDEX;
+    private static readonly GEAR_ICON;
+    private static readonly ACCOUNTS_ICON;
+    readonly minimumWidth: number;
+    readonly maximumWidth: number;
+    readonly minimumHeight: number;
+    readonly maximumHeight: number;
+    private content;
+    private menuBar;
+    private menuBarContainer;
+    private compositeBar;
+    private compositeBarContainer;
+    private globalActivityAction;
+    private globalActivityActionBar;
+    private globalActivitiesContainer;
+    private readonly globalActivity;
+    private accountsActivityAction;
+    private readonly accountsActivity;
+    private readonly compositeActions;
+    private readonly viewContainerDisposables;
+    private readonly keyboardNavigationDisposables;
+    private readonly location;
+    private hasExtensionsRegistered;
+    private readonly enabledViewContainersContextKeys;
+    constructor(paneCompositePart: IPaneCompositePart, instantiationService: IInstantiationService, layoutService: IWorkbenchLayoutService, themeService: IThemeService, storageService: IStorageService, extensionService: IExtensionService, viewDescriptorService: IViewDescriptorService, contextKeyService: IContextKeyService, configurationService: IConfigurationService, environmentService: IWorkbenchEnvironmentService);
+    private createCompositeBar;
+    private getActivityHoverOptions;
+    private getContextMenuActionsForComposite;
+    private registerListeners;
+    private onDidChangeViewContainers;
+    private onDidChangeViewContainerLocation;
+    private onDidChangeViewContainerVisibility;
+    private onDidRegisterExtensions;
+    private onDidViewContainerVisible;
+    showActivity(viewContainerOrActionId: string, badge: IBadge, clazz?: string, priority?: number): IDisposable;
+    private showGlobalActivity;
+    private removeGlobalActivity;
+    private updateGlobalActivity;
+    private getCumulativeNumberBadge;
+    private uninstallMenubar;
+    private installMenubar;
+    protected createContentArea(parent: HTMLElement): HTMLElement;
+    private registerKeyboardNavigationListeners;
+    private createGlobalActivityActionBar;
+    private toggleAccountsActivity;
+    private getCompositeActions;
+    private onDidRegisterViewContainers;
+    private onDidDeregisterViewContainer;
+    private updateActivity;
+    private toActivity;
+    private static toActivity;
+    private showOrHideViewContainer;
+    private shouldBeHidden;
+    private addComposite;
+    private hideComposite;
+    private removeComposite;
+    getPinnedPaneCompositeIds(): string[];
+    getVisiblePaneCompositeIds(): string[];
+    focus(): void;
+    updateStyles(): void;
+    private getActivitybarItemColors;
+    layout(width: number, height: number): void;
+    private getViewContainer;
+    private getViewContainers;
+    private onDidStorageValueChange;
+    private saveCachedViewContainers;
+    private _cachedViewContainers;
+    private get cachedViewContainers();
+    private storeCachedViewContainersState;
+    private getPinnedViewContainers;
+    private setPinnedViewContainers;
+    private _pinnedViewContainersValue;
+    private get pinnedViewContainersValue();
+    private set pinnedViewContainersValue(value);
+    private getStoredPinnedViewContainersValue;
+    private setStoredPinnedViewContainersValue;
+    private getPlaceholderViewContainers;
+    private setPlaceholderViewContainers;
+    private _placeholderViewContainersValue;
+    private get placeholderViewContainersValue();
+    private set placeholderViewContainersValue(value);
+    private getStoredPlaceholderViewContainersValue;
+    private setStoredPlaceholderViewContainersValue;
+    private get accountsVisibilityPreference();
+    private set accountsVisibilityPreference(value);
+    toJSON(): object;
+}
+
+declare class HoverService implements IHoverService {
+    private readonly _instantiationService;
+    private readonly _contextViewService;
+    private readonly _keybindingService;
+    readonly _serviceBrand: undefined;
+    private _currentHoverOptions;
+    private _currentHover;
+    private _lastFocusedElementBeforeOpen;
+    constructor(_instantiationService: IInstantiationService, _contextViewService: IContextViewService, contextMenuService: IContextMenuService, _keybindingService: IKeybindingService);
+    showHover(options: IHoverOptions, focus?: boolean): IHoverWidget | undefined;
+    hideHover(): void;
+    private _intersectionChange;
+    private _keyDown;
+    private _keyUp;
+}
+
+interface IActivityHoverOptions {
+    readonly position: () => HoverPosition;
+}
+
+interface IPanelPartOptions extends IPartOptions {
+    hasTitle: true;
+    borderWidth?: (() => number);
+    useIcons?: boolean;
+}
+declare abstract class BasePanelPart extends CompositePart<PaneComposite> implements IPaneCompositePart, IPaneCompositeSelectorPart {
+    private readonly viewDescriptorService;
+    protected readonly contextKeyService: IContextKeyService;
+    private readonly extensionService;
+    private readonly partId;
+    private readonly pinnedPanelsKey;
+    private readonly placeholdeViewContainersKey;
+    private readonly backgroundColor;
+    private readonly viewContainerLocation;
+    private readonly activePanelContextKey;
+    private panelFocusContextKey;
+    private readonly panelOptions;
+    private static readonly MIN_COMPOSITE_BAR_WIDTH;
+    readonly _serviceBrand: undefined;
+    readonly minimumWidth: number;
+    readonly maximumWidth: number;
+    readonly minimumHeight: number;
+    readonly maximumHeight: number;
+    readonly snap = true;
+    get preferredHeight(): number | undefined;
+    get preferredWidth(): number | undefined;
+    get onDidPaneCompositeOpen(): Event<IPaneComposite>;
+    readonly onDidPaneCompositeClose: Event<IPaneComposite>;
+    private compositeBar;
+    private readonly compositeActions;
+    private globalToolBar;
+    private globalActions;
+    private readonly panelDisposables;
+    private blockOpeningPanel;
+    protected contentDimension: Dimension | undefined;
+    private extensionsRegistered;
+    private panelRegistry;
+    private dndHandler;
+    private readonly enabledViewContainersContextKeys;
+    constructor(notificationService: INotificationService, storageService: IStorageService, telemetryService: ITelemetryService, contextMenuService: IContextMenuService, layoutService: IWorkbenchLayoutService, keybindingService: IKeybindingService, instantiationService: IInstantiationService, themeService: IThemeService, viewDescriptorService: IViewDescriptorService, contextKeyService: IContextKeyService, extensionService: IExtensionService, partId: Parts.PANEL_PART | Parts.AUXILIARYBAR_PART, activePanelSettingsKey: string, pinnedPanelsKey: string, placeholdeViewContainersKey: string, panelRegistryId: string, backgroundColor: string, viewContainerLocation: ViewContainerLocation, activePanelContextKey: IContextKey<string>, panelFocusContextKey: IContextKey<boolean>, panelOptions: IPanelPartOptions);
+    protected abstract getActivityHoverOptions(): IActivityHoverOptions;
+    protected abstract fillExtraContextMenuActions(actions: IAction[]): void;
+    private getContextMenuActionsForComposite;
+    private onDidRegisterPanels;
+    private onDidDeregisterPanel;
+    private updateActivity;
+    private toActivity;
+    private static toActivity;
+    private showOrHideViewContainer;
+    private shouldBeHidden;
+    private registerListeners;
+    private onDidRegisterExtensions;
+    private hideComposite;
+    private onPanelOpen;
+    private onPanelClose;
+    create(parent: HTMLElement): void;
+    private createEmptyPanelMessage;
+    protected createTitleArea(parent: HTMLElement): HTMLElement;
+    updateStyles(): void;
+    doOpenPanel(id: string, focus?: boolean): PaneComposite | undefined;
+    openPaneComposite(id?: string, focus?: boolean): Promise<PaneComposite | undefined>;
+    showActivity(panelId: string, badge: IBadge, clazz?: string): IDisposable;
+    getPaneComposite(panelId: string): PaneCompositeDescriptor | undefined;
+    getPaneComposites(): PaneCompositeDescriptor[];
+    getPinnedPaneCompositeIds(): string[];
+    getVisiblePaneCompositeIds(): string[];
+    getActivePaneComposite(): IPaneComposite | undefined;
+    getLastActivePaneCompositeId(): string;
+    hideActivePaneComposite(): void;
+    protected createTitleLabel(parent: HTMLElement): ICompositeTitleLabel;
+    protected onTitleAreaUpdate(compositeId: string): void;
+    layout(width: number, height: number, top: number, left: number): void;
+    private layoutCompositeBar;
+    private emptyPanelMessageElement;
+    private layoutEmptyMessage;
+    private getViewContainer;
+    private updateGlobalToolbarActions;
+    private getCompositeActions;
+    protected removeComposite(compositeId: string): boolean;
+    protected getToolbarWidth(): number;
+    private onDidStorageValueChange;
+    private saveCachedPanels;
+    private getCachedPanels;
+    private _cachedPanelsValue;
+    private get cachedPanelsValue();
+    private set cachedPanelsValue(value);
+    private getStoredCachedPanelsValue;
+    private setStoredCachedViewletsValue;
+    private getPlaceholderViewContainers;
+    private setPlaceholderViewContainers;
+    private _placeholderViewContainersValue;
+    private get placeholderViewContainersValue();
+    private set placeholderViewContainersValue(value);
+    private getStoredPlaceholderViewContainersValue;
+    private setStoredPlaceholderViewContainersValue;
+}
+declare class PanelPart extends BasePanelPart {
+    private commandService;
+    private menuService;
+    static readonly activePanelSettingsKey = "workbench.panelpart.activepanelid";
+    constructor(notificationService: INotificationService, storageService: IStorageService, telemetryService: ITelemetryService, contextMenuService: IContextMenuService, layoutService: IWorkbenchLayoutService, keybindingService: IKeybindingService, instantiationService: IInstantiationService, themeService: IThemeService, viewDescriptorService: IViewDescriptorService, contextKeyService: IContextKeyService, extensionService: IExtensionService, commandService: ICommandService, menuService: IMenuService);
+    updateStyles(): void;
+    protected getActivityHoverOptions(): IActivityHoverOptions;
+    protected fillExtraContextMenuActions(actions: IAction[]): void;
+    layout(width: number, height: number, top: number, left: number): void;
+    toJSON(): object;
+}
 
 /**
  * The Codicon library is a set of default icons that are built-in in VS Code.
@@ -561,6 +1066,57 @@ declare const Codicon: {
     readonly quickInputBack: ThemeIcon;
 };
 
+declare class StatusbarPart extends Part implements IStatusbarService {
+    private readonly instantiationService;
+    private readonly contextService;
+    private readonly storageService;
+    private contextMenuService;
+    private readonly contextKeyService;
+    private readonly hoverService;
+    private readonly configurationService;
+    readonly _serviceBrand: undefined;
+    readonly minimumWidth: number;
+    readonly maximumWidth: number;
+    readonly minimumHeight: number;
+    readonly maximumHeight: number;
+    private styleElement;
+    private pendingEntries;
+    private readonly viewModel;
+    readonly onDidChangeEntryVisibility: Event<{
+        id: string;
+        visible: boolean;
+    }>;
+    private leftItemsContainer;
+    private rightItemsContainer;
+    private readonly hoverDelegate;
+    private readonly compactEntriesDisposable;
+    private readonly styleOverrides;
+    constructor(instantiationService: IInstantiationService, themeService: IThemeService, contextService: IWorkspaceContextService, storageService: IStorageService, layoutService: IWorkbenchLayoutService, contextMenuService: IContextMenuService, contextKeyService: IContextKeyService, hoverService: IHoverService, configurationService: IConfigurationService);
+    private registerListeners;
+    addEntry(entry: IStatusbarEntry, id: string, alignment: StatusbarAlignment, priorityOrLocation?: number | IStatusbarEntryLocation | IStatusbarEntryPriority): IStatusbarEntryAccessor;
+    private doAddPendingEntry;
+    private doAddEntry;
+    private doCreateStatusItem;
+    private doAddOrRemoveModelEntry;
+    isEntryVisible(id: string): boolean;
+    updateEntryVisibility(id: string, visible: boolean): void;
+    focusNextEntry(): void;
+    focusPreviousEntry(): void;
+    isEntryFocused(): boolean;
+    focus(preserveEntryFocus?: boolean): void;
+    protected createContentArea(parent: HTMLElement): HTMLElement;
+    private createInitialStatusbarEntries;
+    private appendStatusbarEntries;
+    private appendStatusbarEntry;
+    private updateCompactEntries;
+    private showContextMenu;
+    private getContextMenuActions;
+    updateStyles(): void;
+    layout(width: number, height: number, top: number, left: number): void;
+    overrideStyle(style: IStatusbarStyleOverride): IDisposable;
+    toJSON(): object;
+}
+
 declare function renderActivitybarPar(container: HTMLElement): IDisposable;
 declare function renderSidebarPart(container: HTMLElement): IDisposable;
 declare function renderPanelPart(container: HTMLElement): IDisposable;
@@ -587,4 +1143,4 @@ interface CustomViewOption {
 declare function registerCustomView(options: CustomViewOption): IDisposable;
 declare function getServiceOverride(openEditorFallback?: OpenEditor): IEditorOverrideServices;
 
-export { CustomViewOption, OpenEditor, ViewContainerLocation, getServiceOverride as default, registerCustomView, renderActivitybarPar, renderEditorPart, renderPanelPart, renderSidebarPart, renderStatusBarPart };
+export { ActivityService, ActivitybarPart, CustomViewOption, HoverService, OpenEditor, PanelPart, SidebarPart, StatusbarPart, ViewContainerLocation, getServiceOverride as default, registerCustomView, renderActivitybarPar, renderEditorPart, renderPanelPart, renderSidebarPart, renderStatusBarPart };

package/dist/service-override/views.js

@@ -307,4 +307,4 @@ function getServiceOverride(openEditorFallback) {
         [( IHistoryService.toString())]: new SyncDescriptor(HistoryService)
     };
 }
-export { getServiceOverride as default, registerCustomView, renderActivitybarPar, renderEditorPart, renderPanelPart, renderSidebarPart, renderStatusBarPart };
+export { ActivityService, ActivitybarPart, HoverService, PanelPart, SidebarPart, StatusbarPart, getServiceOverride as default, registerCustomView, renderActivitybarPar, renderEditorPart, renderPanelPart, renderSidebarPart, renderStatusBarPart };