@codingame/monaco-vscode-api 4.5.0-improve-code-splitting.1 → 4.5.1

package/service-override/workbench.d.ts

@@ -0,0 +1,18 @@
+import { IEditorOverrideServices } from '../vscode/src/vs/editor/standalone/browser/standaloneServices.js';
+import { IWorkbenchOptions } from '../vscode/src/vs/workbench/browser/workbench.js';
+export { CustomViewOption, EditorPane, SimpleEditorInput, SimpleEditorPane, getPanelPosition, getSideBarPosition, isPartVisibile, onDidChangePanelPosition, onDidChangeSideBarPosition, registerCustomView, registerEditor, registerEditorPane, registerEditorSerializer, setPartVisibility, viewContainerRegistry, viewRegistry } from './tools/views.js';
+export { IViewContainerDescriptor, IViewDescriptor, ViewContainer, ViewContainerLocation } from '../vscode/src/vs/workbench/common/views.js';
+export { ViewPaneContainer } from '../vscode/src/vs/workbench/browser/parts/views/viewPaneContainer.js';
+export { EditorInput, IEditorCloseHandler } from '../vscode/src/vs/workbench/common/editor/editorInput.js';
+export { ConfirmResult } from '../vscode/src/vs/platform/dialogs/common/dialogs.js';
+export { EditorInputFactoryObject, RegisteredEditorInfo, RegisteredEditorOptions, RegisteredEditorPriority } from '../vscode/src/vs/workbench/services/editor/common/editorResolverService.js';
+export { AbstractResourceEditorInput } from '../vscode/src/vs/workbench/common/editor/resourceEditorInput.js';
+export { AbstractTextResourceEditorInput } from '../vscode/src/vs/workbench/common/editor/textResourceEditorInput.js';
+export { EditorInputCapabilities, IEditorSerializer } from '../vscode/src/vs/workbench/common/editor.js';
+export { Parts } from '../vscode/src/vs/workbench/services/layout/browser/layoutService.js';
+export { IView, SplitView } from '../vscode/src/vs/base/browser/ui/splitview/splitview.js';
+export { DomScrollableElement } from '../vscode/src/vs/base/browser/ui/scrollbar/scrollableElement.js';
+
+declare function getServiceOverride(options?: IWorkbenchOptions, _webviewIframeAlternateDomains?: string): IEditorOverrideServices;
+
+export { getServiceOverride as default };

package/service-override/workingCopy.d.ts

@@ -0,0 +1,5 @@
+import { IEditorOverrideServices } from '../vscode/src/vs/editor/standalone/browser/standaloneServices.js';
+
+declare function getServiceOverride(): IEditorOverrideServices;
+
+export { getServiceOverride as default };

package/service-override/workspaceTrust.d.ts

@@ -0,0 +1,5 @@
+import { IEditorOverrideServices } from '../vscode/src/vs/editor/standalone/browser/standaloneServices.js';
+
+declare function getServiceOverride(): IEditorOverrideServices;
+
+export { getServiceOverride as default };

package/services.js

@@ -7,7 +7,6 @@ import './vscode/src/vs/workbench/contrib/codeEditor/browser/workbenchReferenceS
 import './vscode/src/vs/workbench/contrib/codeEditor/browser/menuPreventer.js';
 import './vscode/src/vs/workbench/contrib/codeEditor/browser/diffEditorHelper.js';
 import './vscode/src/vs/workbench/contrib/codeEditor/browser/largeFileOptimizations.js';
-import './vscode/src/vs/workbench/contrib/codeEditor/browser/inspectEditorTokens/inspectEditorTokens.js';
 import './vscode/src/vs/workbench/contrib/codeEditor/browser/saveParticipants.js';
 import './vscode/src/vs/workbench/contrib/codeEditor/browser/toggleMinimap.js';
 import './vscode/src/vs/workbench/contrib/codeEditor/browser/toggleMultiCursorModifier.js';

package/vscode/src/vs/base/browser/indexedDB.d.ts

@@ -0,0 +1,17 @@
+declare class IndexedDB {
+    private readonly name;
+    static create(name: string, version: number | undefined, stores: string[]): Promise<IndexedDB>;
+    private static openDatabase;
+    private static doOpenDatabase;
+    private static deleteDatabase;
+    private database;
+    private readonly pendingTransactions;
+    constructor(database: IDBDatabase, name: string);
+    hasPendingTransactions(): boolean;
+    close(): void;
+    runInTransaction<T>(store: string, transactionMode: IDBTransactionMode, dbRequestFn: (store: IDBObjectStore) => IDBRequest<T>[]): Promise<T[]>;
+    runInTransaction<T>(store: string, transactionMode: IDBTransactionMode, dbRequestFn: (store: IDBObjectStore) => IDBRequest<T>): Promise<T>;
+    getKeyValues<V>(store: string, isValid: (value: unknown) => value is V): Promise<Map<string, V>>;
+}
+
+export { IndexedDB };

package/vscode/src/vs/base/browser/ui/toolbar/toolbar.d.ts

@@ -0,0 +1,62 @@
+import { Event } from '../../../common/event.js';
+import { IContextMenuProvider } from '../../contextmenu.js';
+import { ActionBar, ActionsOrientation, IActionViewItemProvider } from '../actionbar/actionbar.js';
+import { AnchorAlignment } from '../contextview/contextview.js';
+import { IActionRunner, IAction } from '../../../common/actions.js';
+import { ThemeIcon } from '../../../common/themables.js';
+import { ResolvedKeybinding } from '../../../common/keybindings.js';
+import { Disposable } from '../../../common/lifecycle.js';
+import { IHoverDelegate } from '../hover/hoverDelegate.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;
+    skipTelemetry?: boolean;
+    hoverDelegate?: IHoverDelegate;
+    /**
+     * If true, toggled primary items are highlighted with a background color.
+     */
+    highlightToggledItems?: 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;
+}
+
+export { type IToolBarOptions, ToolBar };

package/vscode/src/vs/base/common/worker/simpleWorker.js

@@ -234,11 +234,7 @@ class SimpleWorkerClient extends Disposable {
         }));
         this._protocol.setWorkerId(this._worker.getId());
         let loaderConfiguration = null;
-        const globalRequire = globalThis.require;
-        if (typeof globalRequire !== 'undefined' && typeof globalRequire.getConfig === 'function') {
-            loaderConfiguration = globalRequire.getConfig();
-        }
-        else if (typeof globalThis.requirejs !== 'undefined') {
+        if (typeof globalThis.requirejs !== 'undefined') {
             loaderConfiguration = globalThis.requirejs.s.contexts._.config;
         }
         const hostMethods = getAllMethodNames(host);
@@ -389,7 +385,7 @@ class SimpleWorkerServer {
             globalThis.require.config(loaderConfig);
         }
         return ( new Promise((resolve, reject) => {
-            const req = globalThis.require;
+            const req = undefined;
             req([moduleId], (module) => {
                 this._requestHandler = module.create(hostProxy);
                 if (!this._requestHandler) {

package/vscode/src/vs/editor/common/languages/nullTokenize.js

@@ -1,4 +1,4 @@
-import { EncodedTokenizationResult, TokenizationResult, Token } from '../languages.js';
+import { TokenizationResult, Token, EncodedTokenizationResult } from '../languages.js';
 const NullState = new class {
     clone() {
         return this;

package/vscode/src/vs/editor/common/standaloneStrings.js

@@ -127,6 +127,14 @@ var AccessibilityHelpNLS;
         "The command: Start inline chat is not currentlyt riggerable by a keybinding."
     ));
 })(AccessibilityHelpNLS || (AccessibilityHelpNLS = {})));
+var InspectTokensNLS;
+( (function(InspectTokensNLS) {
+    InspectTokensNLS.inspectTokensAction = ( localizeWithPath(
+        'vs/editor/common/standaloneStrings',
+        'inspectTokens',
+        "Developer: Inspect Tokens"
+    ));
+})(InspectTokensNLS || (InspectTokensNLS = {})));
 var StandaloneCodeEditorNLS;
 ( (function(StandaloneCodeEditorNLS) {
     StandaloneCodeEditorNLS.editorViewAccessibleLabel = ( localizeWithPath(
@@ -140,6 +148,14 @@ var StandaloneCodeEditorNLS;
         "Press Alt+F1 for Accessibility Options."
     ));
 })(StandaloneCodeEditorNLS || (StandaloneCodeEditorNLS = {})));
+var ToggleHighContrastNLS;
+( (function(ToggleHighContrastNLS) {
+    ToggleHighContrastNLS.toggleHighContrast = ( localizeWithPath(
+        'vs/editor/common/standaloneStrings',
+        'toggleHighContrast',
+        "Toggle High Contrast Theme"
+    ));
+})(ToggleHighContrastNLS || (ToggleHighContrastNLS = {})));
 var StandaloneServicesNLS;
 ( (function(StandaloneServicesNLS) {
     StandaloneServicesNLS.bulkEditServiceSummary = ( localizeWithPath(
@@ -148,4 +164,4 @@ var StandaloneServicesNLS;
         "Made {0} edits in {1} files"
     ));
 })(StandaloneServicesNLS || (StandaloneServicesNLS = {})));
-export { AccessibilityHelpNLS, StandaloneCodeEditorNLS, StandaloneServicesNLS };
+export { AccessibilityHelpNLS, InspectTokensNLS, StandaloneCodeEditorNLS, StandaloneServicesNLS, ToggleHighContrastNLS };

package/vscode/src/vs/platform/actions/browser/toolbar.d.ts

@@ -0,0 +1,73 @@
+import { ToolBar, IToolBarOptions } from '../../../base/browser/ui/toolbar/toolbar.js';
+import { IAction } from '../../../base/common/actions.js';
+import { MenuId, IMenuActionOptions } from '../common/actions.js';
+import { IMenuService } from '../common/actions.service.js';
+import { IContextKeyService } from '../../contextkey/common/contextkey.service.js';
+import { IContextMenuService } from '../../contextview/browser/contextView.service.js';
+import { IKeybindingService } from '../../keybinding/common/keybinding.service.js';
+import { ITelemetryService } from '../../telemetry/common/telemetry.service.js';
+
+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;
+    /**
+     * Controls the overflow behavior of the primary group of toolbar. This isthe maximum number of items and id of
+     * items that should never overflow
+     *
+     */
+    overflowBehavior?: {
+        maxItems: number;
+        exempted?: string[];
+    };
+};
+/**
+ * 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;
+}
+
+export { HiddenItemStrategy, type IWorkbenchToolBarOptions, WorkbenchToolBar };

package/vscode/src/vs/platform/files/browser/htmlFileSystemProvider.d.ts

@@ -0,0 +1,43 @@
+import { URI } from '../../../base/common/uri.js';
+import { CancellationToken } from '../../../base/common/cancellation.js';
+import { Event } from '../../../base/common/event.js';
+import { IDisposable } from '../../../base/common/lifecycle.js';
+import { ReadableStreamEvents } from '../../../base/common/stream.js';
+import { IFileSystemProviderWithFileReadWriteCapability, IFileSystemProviderWithFileReadStreamCapability, FileSystemProviderCapabilities, IStat, FileType, IFileReadStreamOptions, IFileWriteOptions, IFileDeleteOptions, IFileOverwriteOptions, IWatchOptions } from '../common/files.js';
+import { IndexedDB } from '../../../base/browser/indexedDB.js';
+import { ILogService } from '../../log/common/log.service.js';
+
+declare class HTMLFileSystemProvider implements IFileSystemProviderWithFileReadWriteCapability, IFileSystemProviderWithFileReadStreamCapability {
+    private indexedDB;
+    private readonly store;
+    private logService;
+    readonly onDidChangeCapabilities: Event<any>;
+    readonly onDidChangeFile: Event<any>;
+    private extUri;
+    private _capabilities;
+    get capabilities(): FileSystemProviderCapabilities;
+    constructor(indexedDB: IndexedDB | undefined, store: string, logService: ILogService);
+    stat(resource: URI): Promise<IStat>;
+    readdir(resource: URI): Promise<[string, FileType][]>;
+    readFileStream(resource: URI, opts: IFileReadStreamOptions, token: CancellationToken): ReadableStreamEvents<Uint8Array>;
+    readFile(resource: URI): Promise<Uint8Array>;
+    writeFile(resource: URI, content: Uint8Array, opts: IFileWriteOptions): Promise<void>;
+    mkdir(resource: URI): Promise<void>;
+    delete(resource: URI, opts: IFileDeleteOptions): Promise<void>;
+    rename(from: URI, to: URI, opts: IFileOverwriteOptions): Promise<void>;
+    watch(resource: URI, opts: IWatchOptions): IDisposable;
+    private readonly _files;
+    private readonly _directories;
+    registerFileHandle(handle: FileSystemFileHandle): Promise<URI>;
+    registerDirectoryHandle(handle: FileSystemDirectoryHandle): Promise<URI>;
+    get directories(): Iterable<FileSystemDirectoryHandle>;
+    private registerHandle;
+    getHandle(resource: URI): Promise<FileSystemHandle | undefined>;
+    private getFileHandle;
+    private getDirectoryHandle;
+    private doGetHandle;
+    private toFileSystemProviderError;
+    private createFileSystemProviderError;
+}
+
+export { HTMLFileSystemProvider };

package/vscode/src/vs/platform/files/browser/indexedDBFileSystemProvider.d.ts

@@ -0,0 +1,48 @@
+import { Event } from '../../../base/common/event.js';
+import { Disposable, IDisposable } from '../../../base/common/lifecycle.js';
+import { URI } from '../../../base/common/uri.js';
+import { IFileSystemProviderWithFileReadWriteCapability, FileSystemProviderCapabilities, IFileChange, IWatchOptions, IStat, IFileWriteOptions, IFileOverwriteOptions, IFileDeleteOptions, FileType } from '../common/files.js';
+import { IndexedDB } from '../../../base/browser/indexedDB.js';
+
+type IndexedDBFileSystemProviderErrorData = {
+    readonly scheme: string;
+    readonly operation: string;
+    readonly code: string;
+};
+type DirEntry = [string, FileType];
+declare class IndexedDBFileSystemProvider extends Disposable implements IFileSystemProviderWithFileReadWriteCapability {
+    readonly scheme: string;
+    private indexedDB;
+    private readonly store;
+    readonly capabilities: FileSystemProviderCapabilities;
+    readonly onDidChangeCapabilities: Event<void>;
+    private readonly extUri;
+    private readonly changesBroadcastChannel;
+    private readonly _onDidChangeFile;
+    readonly onDidChangeFile: Event<readonly IFileChange[]>;
+    private readonly _onReportError;
+    readonly onReportError: Event<IndexedDBFileSystemProviderErrorData>;
+    private readonly mtimes;
+    private cachedFiletree;
+    private writeManyThrottler;
+    constructor(scheme: string, indexedDB: IndexedDB, store: string, watchCrossWindowChanges: boolean);
+    watch(resource: URI, opts: IWatchOptions): IDisposable;
+    mkdir(resource: URI): Promise<void>;
+    stat(resource: URI): Promise<IStat>;
+    readdir(resource: URI): Promise<DirEntry[]>;
+    readFile(resource: URI): Promise<Uint8Array>;
+    writeFile(resource: URI, content: Uint8Array, opts: IFileWriteOptions): Promise<void>;
+    rename(from: URI, to: URI, opts: IFileOverwriteOptions): Promise<void>;
+    delete(resource: URI, opts: IFileDeleteOptions): Promise<void>;
+    private tree;
+    private triggerChanges;
+    private getFiletree;
+    private bulkWrite;
+    private fileWriteBatch;
+    private writeMany;
+    private deleteKeys;
+    reset(): Promise<void>;
+    private reportError;
+}
+
+export { IndexedDBFileSystemProvider, type IndexedDBFileSystemProviderErrorData };

package/vscode/src/vs/platform/files/common/inMemoryFilesystemProvider.d.ts

@@ -0,0 +1,59 @@
+import { Event } from '../../../base/common/event.js';
+import { Disposable, IDisposable } from '../../../base/common/lifecycle.js';
+import { ReadableStreamEvents } from '../../../base/common/stream.js';
+import { URI } from '../../../base/common/uri.js';
+import { IFileSystemProviderWithFileReadWriteCapability, IFileSystemProviderWithOpenReadWriteCloseCapability, IFileSystemProviderWithFileReadStreamCapability, IFileSystemProviderWithFileAtomicReadCapability, IFileSystemProviderWithFileAtomicWriteCapability, IFileSystemProviderWithFileAtomicDeleteCapability, FileSystemProviderCapabilities, IStat, FileType, IFileWriteOptions, IFileOpenOptions, IFileOverwriteOptions, IFileDeleteOptions, IFileChange, IWatchOptions } from './files.js';
+
+declare class File implements IStat {
+    readonly type: FileType.File;
+    readonly ctime: number;
+    mtime: number;
+    size: number;
+    name: string;
+    data?: Uint8Array;
+    constructor(name: string);
+}
+declare class Directory implements IStat {
+    readonly type: FileType.Directory;
+    readonly ctime: number;
+    mtime: number;
+    size: number;
+    name: string;
+    readonly entries: Map<string, File | Directory>;
+    constructor(name: string);
+}
+declare class InMemoryFileSystemProvider extends Disposable implements IFileSystemProviderWithFileReadWriteCapability, IFileSystemProviderWithOpenReadWriteCloseCapability, IFileSystemProviderWithFileReadStreamCapability, IFileSystemProviderWithFileAtomicReadCapability, IFileSystemProviderWithFileAtomicWriteCapability, IFileSystemProviderWithFileAtomicDeleteCapability {
+    private memoryFdCounter;
+    private readonly fdMemory;
+    private _onDidChangeCapabilities;
+    readonly onDidChangeCapabilities: Event<void>;
+    private _capabilities;
+    get capabilities(): FileSystemProviderCapabilities;
+    setReadOnly(readonly: boolean): void;
+    root: Directory;
+    stat(resource: URI): Promise<IStat>;
+    readdir(resource: URI): Promise<[string, FileType][]>;
+    readFile(resource: URI): Promise<Uint8Array>;
+    readFileStream(resource: URI): ReadableStreamEvents<Uint8Array>;
+    writeFile(resource: URI, content: Uint8Array, opts: IFileWriteOptions): Promise<void>;
+    open(resource: URI, opts: IFileOpenOptions): Promise<number>;
+    close(fd: number): Promise<void>;
+    read(fd: number, pos: number, data: Uint8Array, offset: number, length: number): Promise<number>;
+    write(fd: number, pos: number, data: Uint8Array, offset: number, length: number): Promise<number>;
+    rename(from: URI, to: URI, opts: IFileOverwriteOptions): Promise<void>;
+    delete(resource: URI, opts: IFileDeleteOptions): Promise<void>;
+    mkdir(resource: URI): Promise<void>;
+    private _lookup;
+    private _lookupAsDirectory;
+    private _lookupAsFile;
+    private _lookupParentDirectory;
+    private readonly _onDidChangeFile;
+    readonly onDidChangeFile: Event<readonly IFileChange[]>;
+    private _bufferedChanges;
+    private _fireSoonHandle?;
+    watch(resource: URI, opts: IWatchOptions): IDisposable;
+    private _fireSoon;
+    dispose(): void;
+}
+
+export { InMemoryFileSystemProvider };

package/vscode/src/vs/platform/remote/common/remoteExtensionsScanner.service.d.ts

@@ -0,0 +1,13 @@
+import { ServiceIdentifier } from '../../instantiation/common/instantiation.js';
+import { URI } from '../../../base/common/uri.js';
+import { IExtensionDescription } from '../../extensions/common/extensions.js';
+
+declare const IRemoteExtensionsScannerService: ServiceIdentifier<IRemoteExtensionsScannerService>;
+interface IRemoteExtensionsScannerService {
+    readonly _serviceBrand: undefined;
+    whenExtensionsReady(): Promise<void>;
+    scanExtensions(): Promise<IExtensionDescription[]>;
+    scanSingleExtension(extensionLocation: URI, isBuiltin: boolean): Promise<IExtensionDescription | null>;
+}
+
+export { IRemoteExtensionsScannerService };

package/vscode/src/vs/workbench/browser/dnd.d.ts

@@ -0,0 +1,14 @@
+import { IDragAndDropData } from '../../base/browser/dnd.js';
+import '../../editor/editor.api.js';
+
+type Before2D = {
+    readonly verticallyBefore: boolean;
+    readonly horizontallyBefore: boolean;
+};
+interface ICompositeDragAndDrop {
+    drop(data: IDragAndDropData, target: string | undefined, originalEvent: DragEvent, before?: Before2D): void;
+    onDragOver(data: IDragAndDropData, target: string | undefined, originalEvent: DragEvent): boolean;
+    onDragEnter(data: IDragAndDropData, target: string | undefined, originalEvent: DragEvent): boolean;
+}
+
+export type { Before2D, ICompositeDragAndDrop };

package/vscode/src/vs/workbench/browser/parts/activitybar/activitybarPart.d.ts

@@ -0,0 +1,61 @@
+import { Part } from '../../part.js';
+import { Parts } from '../../../services/layout/browser/layoutService.js';
+import { IWorkbenchLayoutService } from '../../../services/layout/browser/layoutService.service.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { IThemeService } from '../../../../platform/theme/common/themeService.service.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.service.js';
+import { IAction } from '../../../../base/common/actions.js';
+import { IPaneCompositePart } from '../paneCompositePart.js';
+import { PaneCompositeBar, IPaneCompositeBarOptions } from '../paneCompositeBar.js';
+import { IStorageService } from '../../../../platform/storage/common/storage.service.js';
+import { IMenuService } from '../../../../platform/actions/common/actions.service.js';
+import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.service.js';
+import { IViewDescriptorService } from '../../../common/views.service.js';
+import { IExtensionService } from '../../../services/extensions/common/extensions.service.js';
+import { IWorkbenchEnvironmentService } from '../../../services/environment/common/environmentService.service.js';
+
+declare class ActivitybarPart extends Part {
+    private readonly paneCompositePart;
+    private readonly instantiationService;
+    static readonly ACTION_HEIGHT = 48;
+    static readonly pinnedViewContainersKey = "workbench.activity.pinnedViewlets2";
+    static readonly placeholderViewContainersKey = "workbench.activity.placeholderViewlets";
+    static readonly viewContainersWorkspaceStateKey = "workbench.activity.viewletsWorkspaceState";
+    readonly minimumWidth: number;
+    readonly maximumWidth: number;
+    readonly minimumHeight: number;
+    readonly maximumHeight: number;
+    private readonly compositeBar;
+    private content;
+    constructor(paneCompositePart: IPaneCompositePart, instantiationService: IInstantiationService, layoutService: IWorkbenchLayoutService, themeService: IThemeService, storageService: IStorageService);
+    private createCompositeBar;
+    protected createContentArea(parent: HTMLElement): HTMLElement;
+    getPinnedPaneCompositeIds(): string[];
+    getVisiblePaneCompositeIds(): string[];
+    focus(): void;
+    updateStyles(): void;
+    show(focus?: boolean): void;
+    hide(): void;
+    layout(width: number, height: number): void;
+    toJSON(): object;
+}
+declare class ActivityBarCompositeBar extends PaneCompositeBar {
+    private readonly configurationService;
+    private readonly menuService;
+    private element;
+    private menuBar;
+    private menuBarContainer;
+    private compositeBarContainer;
+    private readonly globalCompositeBar;
+    private readonly keyboardNavigationDisposables;
+    constructor(options: IPaneCompositeBarOptions, part: Parts, paneCompositePart: IPaneCompositePart, showGlobalActivities: boolean, instantiationService: IInstantiationService, storageService: IStorageService, extensionService: IExtensionService, viewDescriptorService: IViewDescriptorService, contextKeyService: IContextKeyService, environmentService: IWorkbenchEnvironmentService, configurationService: IConfigurationService, menuService: IMenuService, layoutService: IWorkbenchLayoutService);
+    private fillContextMenuActions;
+    private uninstallMenubar;
+    private installMenubar;
+    private registerKeyboardNavigationListeners;
+    create(parent: HTMLElement): HTMLElement;
+    layout(width: number, height: number): void;
+    getActivityBarContextMenuActions(): IAction[];
+}
+
+export { ActivityBarCompositeBar, ActivitybarPart };

package/vscode/src/vs/workbench/browser/parts/banner/bannerPart.d.ts

@@ -0,0 +1,46 @@
+import { Event } from '../../../../base/common/event.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { IStorageService } from '../../../../platform/storage/common/storage.service.js';
+import { IThemeService } from '../../../../platform/theme/common/themeService.service.js';
+import { Part } from '../../part.js';
+import { IWorkbenchLayoutService } from '../../../services/layout/browser/layoutService.service.js';
+import { IBannerItem } from '../../../services/banner/browser/bannerService.js';
+import { IBannerService } from '../../../services/banner/browser/bannerService.service.js';
+import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.service.js';
+
+declare class BannerPart extends Part implements IBannerService {
+    private readonly contextKeyService;
+    private readonly instantiationService;
+    readonly _serviceBrand: undefined;
+    readonly height: number;
+    readonly minimumWidth: number;
+    readonly maximumWidth: number;
+    get minimumHeight(): number;
+    get maximumHeight(): number;
+    private _onDidChangeSize;
+    get onDidChange(): Event<{
+        width: number;
+        height: number;
+    } | undefined>;
+    private item;
+    private readonly markdownRenderer;
+    private visible;
+    private actionBar;
+    private messageActionsContainer;
+    private focusedActionIndex;
+    constructor(themeService: IThemeService, layoutService: IWorkbenchLayoutService, storageService: IStorageService, contextKeyService: IContextKeyService, instantiationService: IInstantiationService);
+    protected createContentArea(parent: HTMLElement): HTMLElement;
+    private close;
+    private focusActionLink;
+    private getAriaLabel;
+    private getBannerMessage;
+    private setVisibility;
+    focus(): void;
+    focusNextAction(): void;
+    focusPreviousAction(): void;
+    hide(id: string): void;
+    show(item: IBannerItem): void;
+    toJSON(): object;
+}
+
+export { BannerPart };

package/vscode/src/vs/workbench/browser/parts/compositeBarActions.d.ts

@@ -0,0 +1,21 @@
+import { HoverPosition } from '../../../base/browser/ui/hover/hoverWidget.js';
+import { Color } from '../../../base/common/color.js';
+import '../../../editor/editor.api.js';
+
+interface ICompositeBarColors {
+    readonly activeBackgroundColor?: Color;
+    readonly inactiveBackgroundColor?: Color;
+    readonly activeBorderColor?: Color;
+    readonly activeBackground?: Color;
+    readonly activeBorderBottomColor?: Color;
+    readonly activeForegroundColor?: Color;
+    readonly inactiveForegroundColor?: Color;
+    readonly badgeBackground?: Color;
+    readonly badgeForeground?: Color;
+    readonly dragAndDropBorder?: Color;
+}
+interface IActivityHoverOptions {
+    readonly position: () => HoverPosition;
+}
+
+export type { IActivityHoverOptions, ICompositeBarColors };