@codingame/monaco-vscode-api 26.2.2 → 27.0.0

package/vscode/src/vs/platform/accessibilitySignal/browser/accessibilitySignalService.js

@@ -438,65 +438,65 @@ class AccessibilitySignal {
     }
     static {
         this.errorAtPosition = AccessibilitySignal.register({
-            name: ( localize(1679, "Error at Position")),
+            name: ( localize(1703, "Error at Position")),
             sound: Sound.error,
-            announcementMessage: ( localize(1680, "Error")),
+            announcementMessage: ( localize(1704, "Error")),
             settingsKey: "accessibility.signals.positionHasError",
             delaySettingsKey: "accessibility.signalOptions.delays.errorAtPosition"
         });
     }
     static {
         this.warningAtPosition = AccessibilitySignal.register({
-            name: ( localize(1681, "Warning at Position")),
+            name: ( localize(1705, "Warning at Position")),
             sound: Sound.warning,
-            announcementMessage: ( localize(1682, "Warning")),
+            announcementMessage: ( localize(1706, "Warning")),
             settingsKey: "accessibility.signals.positionHasWarning",
             delaySettingsKey: "accessibility.signalOptions.delays.warningAtPosition"
         });
     }
     static {
         this.errorOnLine = AccessibilitySignal.register({
-            name: ( localize(1683, "Error on Line")),
+            name: ( localize(1707, "Error on Line")),
             sound: Sound.error,
             legacySoundSettingsKey: "audioCues.lineHasError",
             legacyAnnouncementSettingsKey: "accessibility.alert.error",
-            announcementMessage: ( localize(1684, "Error on Line")),
+            announcementMessage: ( localize(1708, "Error on Line")),
             settingsKey: "accessibility.signals.lineHasError"
         });
     }
     static {
         this.warningOnLine = AccessibilitySignal.register({
-            name: ( localize(1685, "Warning on Line")),
+            name: ( localize(1709, "Warning on Line")),
             sound: Sound.warning,
             legacySoundSettingsKey: "audioCues.lineHasWarning",
             legacyAnnouncementSettingsKey: "accessibility.alert.warning",
-            announcementMessage: ( localize(1686, "Warning on Line")),
+            announcementMessage: ( localize(1710, "Warning on Line")),
             settingsKey: "accessibility.signals.lineHasWarning"
         });
     }
     static {
         this.foldedArea = AccessibilitySignal.register({
-            name: ( localize(1687, "Folded Area on Line")),
+            name: ( localize(1711, "Folded Area on Line")),
             sound: Sound.foldedArea,
             legacySoundSettingsKey: "audioCues.lineHasFoldedArea",
             legacyAnnouncementSettingsKey: "accessibility.alert.foldedArea",
-            announcementMessage: ( localize(1688, "Folded")),
+            announcementMessage: ( localize(1712, "Folded")),
             settingsKey: "accessibility.signals.lineHasFoldedArea"
         });
     }
     static {
         this.break = AccessibilitySignal.register({
-            name: ( localize(1689, "Breakpoint on Line")),
+            name: ( localize(1713, "Breakpoint on Line")),
             sound: Sound.break,
             legacySoundSettingsKey: "audioCues.lineHasBreakpoint",
             legacyAnnouncementSettingsKey: "accessibility.alert.breakpoint",
-            announcementMessage: ( localize(1690, "Breakpoint")),
+            announcementMessage: ( localize(1714, "Breakpoint")),
             settingsKey: "accessibility.signals.lineHasBreakpoint"
         });
     }
     static {
         this.inlineSuggestion = AccessibilitySignal.register({
-            name: ( localize(1691, "Inline Suggestion on Line")),
+            name: ( localize(1715, "Inline Suggestion on Line")),
             sound: Sound.quickFixes,
             legacySoundSettingsKey: "audioCues.lineHasInlineSuggestion",
             settingsKey: "accessibility.signals.lineHasInlineSuggestion"
@@ -504,114 +504,114 @@ class AccessibilitySignal {
     }
     static {
         this.nextEditSuggestion = AccessibilitySignal.register({
-            name: ( localize(1692, "Next Edit Suggestion on Line")),
+            name: ( localize(1716, "Next Edit Suggestion on Line")),
             sound: Sound.nextEditSuggestion,
             legacySoundSettingsKey: "audioCues.nextEditSuggestion",
             settingsKey: "accessibility.signals.nextEditSuggestion",
-            announcementMessage: ( localize(1693, "Next Edit Suggestion"))
+            announcementMessage: ( localize(1717, "Next Edit Suggestion"))
         });
     }
     static {
         this.terminalQuickFix = AccessibilitySignal.register({
-            name: ( localize(1694, "Terminal Quick Fix")),
+            name: ( localize(1718, "Terminal Quick Fix")),
             sound: Sound.quickFixes,
             legacySoundSettingsKey: "audioCues.terminalQuickFix",
             legacyAnnouncementSettingsKey: "accessibility.alert.terminalQuickFix",
-            announcementMessage: ( localize(1695, "Quick Fix")),
+            announcementMessage: ( localize(1719, "Quick Fix")),
             settingsKey: "accessibility.signals.terminalQuickFix"
         });
     }
     static {
         this.onDebugBreak = AccessibilitySignal.register({
-            name: ( localize(1696, "Debugger Stopped on Breakpoint")),
+            name: ( localize(1720, "Debugger Stopped on Breakpoint")),
             sound: Sound.break,
             legacySoundSettingsKey: "audioCues.onDebugBreak",
             legacyAnnouncementSettingsKey: "accessibility.alert.onDebugBreak",
-            announcementMessage: ( localize(1697, "Breakpoint")),
+            announcementMessage: ( localize(1721, "Breakpoint")),
             settingsKey: "accessibility.signals.onDebugBreak"
         });
     }
     static {
         this.noInlayHints = AccessibilitySignal.register({
-            name: ( localize(1698, "No Inlay Hints on Line")),
+            name: ( localize(1722, "No Inlay Hints on Line")),
             sound: Sound.error,
             legacySoundSettingsKey: "audioCues.noInlayHints",
             legacyAnnouncementSettingsKey: "accessibility.alert.noInlayHints",
-            announcementMessage: ( localize(1699, "No Inlay Hints")),
+            announcementMessage: ( localize(1723, "No Inlay Hints")),
             settingsKey: "accessibility.signals.noInlayHints"
         });
     }
     static {
         this.taskCompleted = AccessibilitySignal.register({
-            name: ( localize(1700, "Task Completed")),
+            name: ( localize(1724, "Task Completed")),
             sound: Sound.taskCompleted,
             legacySoundSettingsKey: "audioCues.taskCompleted",
             legacyAnnouncementSettingsKey: "accessibility.alert.taskCompleted",
-            announcementMessage: ( localize(1701, "Task Completed")),
+            announcementMessage: ( localize(1725, "Task Completed")),
             settingsKey: "accessibility.signals.taskCompleted"
         });
     }
     static {
         this.taskFailed = AccessibilitySignal.register({
-            name: ( localize(1702, "Task Failed")),
+            name: ( localize(1726, "Task Failed")),
             sound: Sound.taskFailed,
             legacySoundSettingsKey: "audioCues.taskFailed",
             legacyAnnouncementSettingsKey: "accessibility.alert.taskFailed",
-            announcementMessage: ( localize(1703, "Task Failed")),
+            announcementMessage: ( localize(1727, "Task Failed")),
             settingsKey: "accessibility.signals.taskFailed"
         });
     }
     static {
         this.terminalCommandFailed = AccessibilitySignal.register({
-            name: ( localize(1704, "Terminal Command Failed")),
+            name: ( localize(1728, "Terminal Command Failed")),
             sound: Sound.error,
             legacySoundSettingsKey: "audioCues.terminalCommandFailed",
             legacyAnnouncementSettingsKey: "accessibility.alert.terminalCommandFailed",
-            announcementMessage: ( localize(1705, "Command Failed")),
+            announcementMessage: ( localize(1729, "Command Failed")),
             settingsKey: "accessibility.signals.terminalCommandFailed"
         });
     }
     static {
         this.terminalCommandSucceeded = AccessibilitySignal.register({
-            name: ( localize(1706, "Terminal Command Succeeded")),
+            name: ( localize(1730, "Terminal Command Succeeded")),
             sound: Sound.terminalCommandSucceeded,
-            announcementMessage: ( localize(1707, "Command Succeeded")),
+            announcementMessage: ( localize(1731, "Command Succeeded")),
             settingsKey: "accessibility.signals.terminalCommandSucceeded"
         });
     }
     static {
         this.terminalBell = AccessibilitySignal.register({
-            name: ( localize(1708, "Terminal Bell")),
+            name: ( localize(1732, "Terminal Bell")),
             sound: Sound.terminalBell,
             legacySoundSettingsKey: "audioCues.terminalBell",
             legacyAnnouncementSettingsKey: "accessibility.alert.terminalBell",
-            announcementMessage: ( localize(1709, "Terminal Bell")),
+            announcementMessage: ( localize(1733, "Terminal Bell")),
             settingsKey: "accessibility.signals.terminalBell"
         });
     }
     static {
         this.notebookCellCompleted = AccessibilitySignal.register({
-            name: ( localize(1710, "Notebook Cell Completed")),
+            name: ( localize(1734, "Notebook Cell Completed")),
             sound: Sound.taskCompleted,
             legacySoundSettingsKey: "audioCues.notebookCellCompleted",
             legacyAnnouncementSettingsKey: "accessibility.alert.notebookCellCompleted",
-            announcementMessage: ( localize(1711, "Notebook Cell Completed")),
+            announcementMessage: ( localize(1735, "Notebook Cell Completed")),
             settingsKey: "accessibility.signals.notebookCellCompleted"
         });
     }
     static {
         this.notebookCellFailed = AccessibilitySignal.register({
-            name: ( localize(1712, "Notebook Cell Failed")),
+            name: ( localize(1736, "Notebook Cell Failed")),
             sound: Sound.taskFailed,
             legacySoundSettingsKey: "audioCues.notebookCellFailed",
             legacyAnnouncementSettingsKey: "accessibility.alert.notebookCellFailed",
-            announcementMessage: ( localize(1713, "Notebook Cell Failed")),
+            announcementMessage: ( localize(1737, "Notebook Cell Failed")),
             settingsKey: "accessibility.signals.notebookCellFailed"
         });
     }
     static {
         this.diffLineInserted = AccessibilitySignal.register({
-            name: ( localize(1714, "Diff Line Inserted")),
+            name: ( localize(1738, "Diff Line Inserted")),
             sound: Sound.diffLineInserted,
             legacySoundSettingsKey: "audioCues.diffLineInserted",
             settingsKey: "accessibility.signals.diffLineInserted"
@@ -619,7 +619,7 @@ class AccessibilitySignal {
     }
     static {
         this.diffLineDeleted = AccessibilitySignal.register({
-            name: ( localize(1715, "Diff Line Deleted")),
+            name: ( localize(1739, "Diff Line Deleted")),
             sound: Sound.diffLineDeleted,
             legacySoundSettingsKey: "audioCues.diffLineDeleted",
             settingsKey: "accessibility.signals.diffLineDeleted"
@@ -627,7 +627,7 @@ class AccessibilitySignal {
     }
     static {
         this.diffLineModified = AccessibilitySignal.register({
-            name: ( localize(1716, "Diff Line Modified")),
+            name: ( localize(1740, "Diff Line Modified")),
             sound: Sound.diffLineModified,
             legacySoundSettingsKey: "audioCues.diffLineModified",
             settingsKey: "accessibility.signals.diffLineModified"
@@ -635,25 +635,25 @@ class AccessibilitySignal {
     }
     static {
         this.chatEditModifiedFile = AccessibilitySignal.register({
-            name: ( localize(1717, "Chat Edit Modified File")),
+            name: ( localize(1741, "Chat Edit Modified File")),
             sound: Sound.chatEditModifiedFile,
-            announcementMessage: ( localize(1718, "File Modified from Chat Edits")),
+            announcementMessage: ( localize(1742, "File Modified from Chat Edits")),
             settingsKey: "accessibility.signals.chatEditModifiedFile"
         });
     }
     static {
         this.chatRequestSent = AccessibilitySignal.register({
-            name: ( localize(1719, "Chat Request Sent")),
+            name: ( localize(1743, "Chat Request Sent")),
             sound: Sound.requestSent,
             legacySoundSettingsKey: "audioCues.chatRequestSent",
             legacyAnnouncementSettingsKey: "accessibility.alert.chatRequestSent",
-            announcementMessage: ( localize(1720, "Chat Request Sent")),
+            announcementMessage: ( localize(1744, "Chat Request Sent")),
             settingsKey: "accessibility.signals.chatRequestSent"
         });
     }
     static {
         this.chatResponseReceived = AccessibilitySignal.register({
-            name: ( localize(1721, "Chat Response Received")),
+            name: ( localize(1745, "Chat Response Received")),
             legacySoundSettingsKey: "audioCues.chatResponseReceived",
             sound: {
                 randomOneOf: [
@@ -668,17 +668,17 @@ class AccessibilitySignal {
     }
     static {
         this.codeActionTriggered = AccessibilitySignal.register({
-            name: ( localize(1722, "Code Action Request Triggered")),
+            name: ( localize(1746, "Code Action Request Triggered")),
             sound: Sound.codeActionTriggered,
             legacySoundSettingsKey: "audioCues.codeActionRequestTriggered",
             legacyAnnouncementSettingsKey: "accessibility.alert.codeActionRequestTriggered",
-            announcementMessage: ( localize(1723, "Code Action Request Triggered")),
+            announcementMessage: ( localize(1747, "Code Action Request Triggered")),
             settingsKey: "accessibility.signals.codeActionTriggered"
         });
     }
     static {
         this.codeActionApplied = AccessibilitySignal.register({
-            name: ( localize(1724, "Code Action Applied")),
+            name: ( localize(1748, "Code Action Applied")),
             legacySoundSettingsKey: "audioCues.codeActionApplied",
             sound: Sound.codeActionApplied,
             settingsKey: "accessibility.signals.codeActionApplied"
@@ -686,47 +686,47 @@ class AccessibilitySignal {
     }
     static {
         this.progress = AccessibilitySignal.register({
-            name: ( localize(1725, "Progress")),
+            name: ( localize(1749, "Progress")),
             sound: Sound.progress,
             legacySoundSettingsKey: "audioCues.chatResponsePending",
             legacyAnnouncementSettingsKey: "accessibility.alert.progress",
-            announcementMessage: ( localize(1726, "Progress")),
+            announcementMessage: ( localize(1750, "Progress")),
             settingsKey: "accessibility.signals.progress"
         });
     }
     static {
         this.clear = AccessibilitySignal.register({
-            name: ( localize(1727, "Clear")),
+            name: ( localize(1751, "Clear")),
             sound: Sound.clear,
             legacySoundSettingsKey: "audioCues.clear",
             legacyAnnouncementSettingsKey: "accessibility.alert.clear",
-            announcementMessage: ( localize(1728, "Clear")),
+            announcementMessage: ( localize(1752, "Clear")),
             settingsKey: "accessibility.signals.clear"
         });
     }
     static {
         this.save = AccessibilitySignal.register({
-            name: ( localize(1729, "Save")),
+            name: ( localize(1753, "Save")),
             sound: Sound.save,
             legacySoundSettingsKey: "audioCues.save",
             legacyAnnouncementSettingsKey: "accessibility.alert.save",
-            announcementMessage: ( localize(1730, "Save")),
+            announcementMessage: ( localize(1754, "Save")),
             settingsKey: "accessibility.signals.save"
         });
     }
     static {
         this.format = AccessibilitySignal.register({
-            name: ( localize(1731, "Format")),
+            name: ( localize(1755, "Format")),
             sound: Sound.format,
             legacySoundSettingsKey: "audioCues.format",
             legacyAnnouncementSettingsKey: "accessibility.alert.format",
-            announcementMessage: ( localize(1732, "Format")),
+            announcementMessage: ( localize(1756, "Format")),
             settingsKey: "accessibility.signals.format"
         });
     }
     static {
         this.voiceRecordingStarted = AccessibilitySignal.register({
-            name: ( localize(1733, "Voice Recording Started")),
+            name: ( localize(1757, "Voice Recording Started")),
             sound: Sound.voiceRecordingStarted,
             legacySoundSettingsKey: "audioCues.voiceRecordingStarted",
             settingsKey: "accessibility.signals.voiceRecordingStarted"
@@ -734,7 +734,7 @@ class AccessibilitySignal {
     }
     static {
         this.voiceRecordingStopped = AccessibilitySignal.register({
-            name: ( localize(1734, "Voice Recording Stopped")),
+            name: ( localize(1758, "Voice Recording Stopped")),
             sound: Sound.voiceRecordingStopped,
             legacySoundSettingsKey: "audioCues.voiceRecordingStopped",
             settingsKey: "accessibility.signals.voiceRecordingStopped"
@@ -742,25 +742,25 @@ class AccessibilitySignal {
     }
     static {
         this.editsKept = AccessibilitySignal.register({
-            name: ( localize(1735, "Edits Kept")),
+            name: ( localize(1759, "Edits Kept")),
             sound: Sound.editsKept,
-            announcementMessage: ( localize(1736, "Edits Kept")),
+            announcementMessage: ( localize(1760, "Edits Kept")),
             settingsKey: "accessibility.signals.editsKept"
         });
     }
     static {
         this.editsUndone = AccessibilitySignal.register({
-            name: ( localize(1737, "Undo Edits")),
+            name: ( localize(1761, "Undo Edits")),
             sound: Sound.editsUndone,
-            announcementMessage: ( localize(1738, "Edits Undone")),
+            announcementMessage: ( localize(1762, "Edits Undone")),
             settingsKey: "accessibility.signals.editsUndone"
         });
     }
     static {
         this.chatUserActionRequired = AccessibilitySignal.register({
-            name: ( localize(1739, "Chat User Action Required")),
+            name: ( localize(1763, "Chat User Action Required")),
             sound: Sound.chatUserActionRequired,
-            announcementMessage: ( localize(1740, "Chat User Action Required")),
+            announcementMessage: ( localize(1764, "Chat User Action Required")),
             settingsKey: "accessibility.signals.chatUserActionRequired"
         });
     }

package/vscode/src/vs/platform/action/common/actionCommonCategories.js

@@ -2,12 +2,12 @@
 import { localize2 } from '../../../nls.js';
 
 const Categories = ( Object.freeze({
-    View: ( localize2(1741, "View")),
-    Help: ( localize2(1742, "Help")),
-    Test: ( localize2(1743, "Test")),
-    File: ( localize2(1744, "File")),
-    Preferences: ( localize2(1745, "Preferences")),
-    Developer: ( localize2(1746, "Developer"))
+    View: ( localize2(1765, "View")),
+    Help: ( localize2(1766, "Help")),
+    Test: ( localize2(1767, "Test")),
+    File: ( localize2(1768, "File")),
+    Preferences: ( localize2(1769, "Preferences")),
+    Developer: ( localize2(1770, "Developer"))
 }));
 
 export { Categories };

package/vscode/src/vs/platform/actionWidget/browser/actionList.d.ts

@@ -1,11 +1,16 @@
+import { StandardMouseEvent } from "../../../base/browser/mouseEvent.js";
+import { IAnchor } from "../../../base/browser/ui/contextview/contextview.js";
 import { IListAccessibilityProvider } from "../../../base/browser/ui/list/listWidget.js";
 import { IAction } from "../../../base/common/actions.js";
 import { CancellationToken } from "../../../base/common/cancellation.js";
+import { IMarkdownString, MarkdownString } from "../../../base/common/htmlContent.js";
 import { ResolvedKeybinding } from "../../../base/common/keybindings.js";
+import { AnchorPosition } from "../../../base/common/layout.js";
 import { Disposable } from "../../../base/common/lifecycle.js";
 import { ThemeIcon } from "../../../base/common/themables.js";
 import { IContextViewService } from "../../contextview/browser/contextView.service.js";
 import { IKeybindingService } from "../../keybinding/common/keybinding.service.js";
+import { IOpenerService } from "../../opener/common/opener.service.js";
 import { ILayoutService } from "../../layout/browser/layoutService.service.js";
 import { IHoverService } from "../../hover/browser/hover.service.js";
 import { IHoverPositionOptions } from "../../../base/browser/ui/hover/hover.js";
@@ -26,7 +31,7 @@ export interface IActionListItemHover {
     /**
      * Content to display in the hover.
      */
-    readonly content?: string;
+    readonly content?: string | MarkdownString;
     readonly position?: IHoverPositionOptions;
 }
 export interface IActionListItem<T> {
@@ -39,7 +44,7 @@ export interface IActionListItem<T> {
     };
     readonly disabled?: boolean;
     readonly label?: string;
-    readonly description?: string;
+    readonly description?: string | IMarkdownString;
     /**
      * Optional hover configuration shown when focusing/hovering over the item.
      */
@@ -52,35 +57,125 @@ export interface IActionListItem<T> {
      * Optional toolbar actions shown when the item is focused or hovered.
      */
     readonly toolbarActions?: IAction[];
+    /**
+     * Optional section identifier. Items with the same section belong to the same
+     * collapsible group. Only meaningful when the ActionList is created with
+     * collapsible sections.
+     */
+    readonly section?: string;
+    /**
+     * When true, clicking this item toggles the section's collapsed state
+     * instead of selecting it.
+     */
+    readonly isSectionToggle?: boolean;
+    /**
+     * Optional CSS class name to add to the row container.
+     */
+    readonly className?: string;
+    /**
+     * Optional badge text to display after the label (e.g., "New").
+     */
+    readonly badge?: string;
+    /**
+     * When true, this item is always shown when filtering produces no other results.
+     */
+    readonly showAlways?: boolean;
+    /**
+     * Optional callback invoked when the item is removed via the built-in remove button.
+     * When set, a close button is automatically added to the item toolbar.
+     */
+    readonly onRemove?: () => void;
 }
 export declare enum ActionListItemKind {
     Action = "action",
     Header = "header",
     Separator = "separator"
 }
+/**
+ * Options for configuring the action list.
+ */
+export interface IActionListOptions {
+    /**
+     * When true, shows a filter input.
+     */
+    readonly showFilter?: boolean;
+    /**
+     * Placeholder text for the filter input.
+     */
+    readonly filterPlaceholder?: string;
+    /**
+     * Section IDs that should be collapsed by default.
+     */
+    readonly collapsedByDefault?: ReadonlySet<string>;
+    /**
+     * Minimum width for the action list.
+     */
+    readonly minWidth?: number;
+    /**
+     * When true and filtering is enabled, focuses the filter input when the list opens.
+     */
+    readonly focusFilterOnOpen?: boolean;
+}
 export declare class ActionList<T> extends Disposable {
     private readonly _delegate;
+    private readonly _options;
+    private readonly _anchor;
     private readonly _contextViewService;
     private readonly _keybindingService;
     private readonly _layoutService;
     private readonly _hoverService;
+    private readonly _openerService;
     readonly domNode: HTMLElement;
     private readonly _list;
     private readonly _actionLineHeight;
     private readonly _headerLineHeight;
     private readonly _separatorLineHeight;
-    private readonly _allMenuItems;
+    private _allMenuItems;
     private readonly cts;
     private _hover;
-    constructor(user: string, preview: boolean, items: readonly IActionListItem<T>[], _delegate: IActionListDelegate<T>, accessibilityProvider: Partial<IListAccessibilityProvider<IActionListItem<T>>> | undefined, _contextViewService: IContextViewService, _keybindingService: IKeybindingService, _layoutService: ILayoutService, _hoverService: IHoverService);
+    private readonly _collapsedSections;
+    private _filterText;
+    private _suppressHover;
+    private readonly _filterInput;
+    private readonly _filterContainer;
+    private _lastMinWidth;
+    private _cachedMaxWidth;
+    private _hasLaidOut;
+    private _showAbove;
+    /**
+     * Returns the resolved anchor position after the first layout.
+     * Used by the context view delegate to lock the dropdown direction.
+     */
+    get anchorPosition(): AnchorPosition | undefined;
+    constructor(user: string, preview: boolean, items: readonly IActionListItem<T>[], _delegate: IActionListDelegate<T>, accessibilityProvider: Partial<IListAccessibilityProvider<IActionListItem<T>>> | undefined, _options: IActionListOptions | undefined, _anchor: HTMLElement | StandardMouseEvent | IAnchor, _contextViewService: IContextViewService, _keybindingService: IKeybindingService, _layoutService: ILayoutService, _hoverService: IHoverService, _openerService: IOpenerService);
+    private _toggleSection;
+    private _applyFilter;
+    /**
+     * Returns the filter container element, if filter is enabled.
+     * The caller is responsible for appending it to the widget DOM.
+     */
+    get filterContainer(): HTMLElement | undefined;
+    get filterInput(): HTMLInputElement | undefined;
     private focusCondition;
+    focus(): void;
+    private _focusCheckedOrFirst;
     hide(didCancel?: boolean): void;
+    clearFilter(): boolean;
+    private hasDynamicHeight;
+    private computeHeight;
+    private computeMaxWidth;
     layout(minWidth: number): number;
     focusPrevious(): void;
     focusNext(): void;
+    collapseFocusedSection(): void;
+    expandFocusedSection(): void;
+    toggleFocusedSection(): boolean;
+    private _getFocusedSection;
     acceptSelected(preview?: boolean): void;
     private onListSelection;
     private onFocus;
+    private _removeItem;
+    private _computeToolbarWidth;
     private _getRowElement;
     private _showHoverForElement;
     private onListHover;