@codingame/monaco-vscode-notebook-service-override 11.1.2 → 12.0.0

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/notebookVariables/notebookVariablesDataSource.d.ts

@@ -0,0 +1,38 @@
+import { IAsyncDataSource } from "vscode/vscode/vs/base/browser/ui/tree/tree";
+import { NotebookTextModel } from "../../../common/model/notebookTextModel.js";
+import { INotebookKernelService } from "vscode/vscode/vs/workbench/contrib/notebook/common/notebookKernelService.service";
+export interface IEmptyScope {
+    kind: "empty";
+}
+export interface INotebookScope {
+    kind: "root";
+    readonly notebook: NotebookTextModel;
+}
+export interface INotebookVariableElement {
+    kind: "variable";
+    readonly id: string;
+    readonly extHostId: number;
+    readonly name: string;
+    readonly value: string;
+    readonly type?: string;
+    readonly interfaces?: string[];
+    readonly expression?: string;
+    readonly language?: string;
+    readonly indexedChildrenCount: number;
+    readonly indexStart?: number;
+    readonly hasNamedChildren: boolean;
+    readonly notebook: NotebookTextModel;
+    readonly extensionId?: string;
+}
+export declare class NotebookVariableDataSource implements IAsyncDataSource<INotebookScope, INotebookVariableElement> {
+    private readonly notebookKernelService;
+    private cancellationTokenSource;
+    constructor(notebookKernelService: INotebookKernelService);
+    hasChildren(element: INotebookScope | INotebookVariableElement): boolean;
+    cancel(): void;
+    getChildren(element: INotebookScope | INotebookVariableElement | IEmptyScope): Promise<Array<INotebookVariableElement>>;
+    private getVariables;
+    private getIndexedChildren;
+    private getRootVariables;
+    private createVariableElement;
+}

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/notebookVariables/notebookVariablesDataSource.js

@@ -1,3 +1,4 @@
+
 import { CancellationTokenSource } from 'vscode/vscode/vs/base/common/cancellation';
 import { localize } from 'vscode/vscode/vs/nls';
 import { variablePageSize } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookKernelService';
@@ -5,7 +6,7 @@ import { variablePageSize } from 'vscode/vscode/vs/workbench/contrib/notebook/co
 class NotebookVariableDataSource {
     constructor(notebookKernelService) {
         this.notebookKernelService = notebookKernelService;
-        this.cancellationTokenSource = ( (new CancellationTokenSource()));
+        this.cancellationTokenSource = ( new CancellationTokenSource());
     }
     hasChildren(element) {
         return element.kind === 'root' || element.hasNamedChildren || element.indexedChildrenCount > 0;
@@ -13,7 +14,7 @@ class NotebookVariableDataSource {
     cancel() {
         this.cancellationTokenSource.cancel();
         this.cancellationTokenSource.dispose();
-        this.cancellationTokenSource = ( (new CancellationTokenSource()));
+        this.cancellationTokenSource = ( new CancellationTokenSource());
     }
     async getChildren(element) {
         if (element.kind === 'empty') {
@@ -32,10 +33,10 @@ class NotebookVariableDataSource {
             let children = [];
             if (parent.hasNamedChildren) {
                 const variables = selectedKernel.provideVariables(parent.notebook.uri, parent.extHostId, 'named', 0, this.cancellationTokenSource.token);
-                const childNodes = await ( (variables
+                const childNodes = await ( variables
                     .map(
                     variable => { return this.createVariableElement(variable, parent.notebook); }
-                )))
+                ))
                     .toPromise();
                 children = children.concat(childNodes);
             }
@@ -77,7 +78,7 @@ class NotebookVariableDataSource {
                     notebook: parent.notebook,
                     id: parent.id + `${last + 1}`,
                     extHostId: parent.extHostId,
-                    name: ( localize(11744, "Display limit reached")),
+                    name: ( localize(7379, "Display limit reached")),
                     value: '',
                     indexedChildrenCount: 0,
                     hasNamedChildren: false
@@ -99,8 +100,8 @@ class NotebookVariableDataSource {
         const selectedKernel = this.notebookKernelService.getMatchingKernel(notebook).selected;
         if (selectedKernel && selectedKernel.hasVariableProvider) {
             const variables = selectedKernel.provideVariables(notebook.uri, undefined, 'named', 0, this.cancellationTokenSource.token);
-            return await ( (variables
-                .map(variable => { return this.createVariableElement(variable, notebook); })))
+            return await ( variables
+                .map(variable => { return this.createVariableElement(variable, notebook); }))
                 .toPromise();
         }
         return [];

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/notebookVariables/notebookVariablesTree.d.ts

@@ -0,0 +1,34 @@
+import { IListVirtualDelegate } from "vscode/vscode/vs/base/browser/ui/list/list";
+import { IListAccessibilityProvider } from "vscode/vscode/vs/base/browser/ui/list/listWidget";
+import { ITreeNode, ITreeRenderer } from "vscode/vscode/vs/base/browser/ui/tree/tree";
+import { FuzzyScore } from "vscode/vscode/vs/base/common/filters";
+import { DisposableStore } from "vscode/vscode/vs/base/common/lifecycle";
+import { IInstantiationService } from "vscode/vscode/vs/platform/instantiation/common/instantiation";
+import { WorkbenchObjectTree } from "vscode/vscode/vs/platform/list/browser/listService";
+import { INotebookVariableElement } from "./notebookVariablesDataSource.js";
+export declare class NotebookVariablesTree extends WorkbenchObjectTree<INotebookVariableElement> {
+}
+export declare class NotebookVariablesDelegate implements IListVirtualDelegate<INotebookVariableElement> {
+    getHeight(element: INotebookVariableElement): number;
+    getTemplateId(element: INotebookVariableElement): string;
+}
+export interface IVariableTemplateData {
+    expression: HTMLElement;
+    name: HTMLSpanElement;
+    value: HTMLSpanElement;
+    elementDisposables: DisposableStore;
+}
+export declare class NotebookVariableRenderer implements ITreeRenderer<INotebookVariableElement, FuzzyScore, IVariableTemplateData> {
+    private expressionRenderer;
+    static readonly ID = "variableElement";
+    get templateId(): string;
+    constructor(instantiationService: IInstantiationService);
+    renderTemplate(container: HTMLElement): IVariableTemplateData;
+    renderElement(element: ITreeNode<INotebookVariableElement, FuzzyScore>, _index: number, data: IVariableTemplateData): void;
+    disposeElement(element: ITreeNode<INotebookVariableElement, FuzzyScore>, index: number, templateData: IVariableTemplateData, height: number | undefined): void;
+    disposeTemplate(templateData: IVariableTemplateData): void;
+}
+export declare class NotebookVariableAccessibilityProvider implements IListAccessibilityProvider<INotebookVariableElement> {
+    getWidgetAriaLabel(): string;
+    getAriaLabel(element: INotebookVariableElement): string;
+}

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/notebookVariables/notebookVariablesTree.js

@@ -1,10 +1,11 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { $ as $$1, append } from 'vscode/vscode/vs/base/browser/dom';
 import { DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
 import { localize } from 'vscode/vscode/vs/nls';
 import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
 import 'vscode/vscode/vs/platform/list/browser/listService';
-import { DebugExpressionRenderer } from '@codingame/monaco-vscode-debug-notebook-common/vscode/vs/workbench/contrib/debug/browser/debugExpressionRenderer';
+import { DebugExpressionRenderer } from '@codingame/monaco-vscode-88aa9a78-75f5-5aaa-89e9-bbdd580b3b5c-common/vscode/vs/workbench/contrib/debug/browser/debugExpressionRenderer';
 
 var NotebookVariableRenderer_1;
 const $ = $$1;
@@ -30,7 +31,7 @@ let NotebookVariableRenderer = class NotebookVariableRenderer {
         const expression = append(container, $('.expression'));
         const name = append(expression, $('span.name'));
         const value = append(expression, $('span.value'));
-        const template = { expression, name, value, elementDisposables: ( (new DisposableStore())) };
+        const template = { expression, name, value, elementDisposables: ( new DisposableStore()) };
         return template;
     }
     renderElement(element, _index, data) {
@@ -50,15 +51,15 @@ let NotebookVariableRenderer = class NotebookVariableRenderer {
         templateData.elementDisposables.dispose();
     }
 };
-NotebookVariableRenderer = NotebookVariableRenderer_1 = ( (__decorate([
-    ( (__param(0, IInstantiationService)))
-], NotebookVariableRenderer)));
+NotebookVariableRenderer = NotebookVariableRenderer_1 = ( __decorate([
+    ( __param(0, IInstantiationService))
+], NotebookVariableRenderer));
 class NotebookVariableAccessibilityProvider {
     getWidgetAriaLabel() {
-        return ( localize(11745, "Notebook Variables"));
+        return localize(7380, "Notebook Variables");
     }
     getAriaLabel(element) {
-        return ( localize(11746, "Variable {0}, value {1}", element.name, element.value));
+        return localize(7381, "Variable {0}, value {1}", element.name, element.value);
     }
 }
 

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/notebookVariables/notebookVariablesView.d.ts

@@ -0,0 +1,53 @@
+import { ILocalizedString } from "vscode/vscode/vs/platform/action/common/action";
+import { IMenuService } from "vscode/vscode/vs/platform/actions/common/actions.service";
+import { ICommandService } from "vscode/vscode/vs/platform/commands/common/commands.service";
+import { IConfigurationService } from "vscode/vscode/vs/platform/configuration/common/configuration.service";
+import { IContextKeyService } from "vscode/vscode/vs/platform/contextkey/common/contextkey.service";
+import { IContextMenuService } from "vscode/vscode/vs/platform/contextview/browser/contextView.service";
+import { IHoverService } from "vscode/vscode/vs/platform/hover/browser/hover.service";
+import { IInstantiationService } from "vscode/vscode/vs/platform/instantiation/common/instantiation";
+import { IKeybindingService } from "vscode/vscode/vs/platform/keybinding/common/keybinding.service";
+import { IOpenerService } from "vscode/vscode/vs/platform/opener/common/opener.service";
+import { IQuickInputService } from "vscode/vscode/vs/platform/quickinput/common/quickInput.service";
+import { ITelemetryService } from "vscode/vscode/vs/platform/telemetry/common/telemetry.service";
+import { IThemeService } from "vscode/vscode/vs/platform/theme/common/themeService.service";
+import { IViewPaneOptions, ViewPane } from "@codingame/monaco-vscode-65619f8f-0eab-5d8b-855a-43b6353fe527-common/vscode/vs/workbench/browser/parts/views/viewPane";
+import { IViewDescriptorService } from "vscode/vscode/vs/workbench/common/views.service";
+import { INotebookExecutionStateService } from "vscode/vscode/vs/workbench/contrib/notebook/common/notebookExecutionStateService.service";
+import { INotebookKernelService } from "vscode/vscode/vs/workbench/contrib/notebook/common/notebookKernelService.service";
+import { IEditorService } from "vscode/vscode/vs/workbench/services/editor/common/editorService.service";
+export type contextMenuArg = {
+    source: string;
+    name: string;
+    type?: string;
+    value?: string;
+    expression?: string;
+    language?: string;
+    extensionId?: string;
+};
+export declare class NotebookVariablesView extends ViewPane {
+    private readonly editorService;
+    private readonly notebookKernelService;
+    private readonly notebookExecutionStateService;
+    protected quickInputService: IQuickInputService;
+    protected commandService: ICommandService;
+    private readonly menuService;
+    static readonly ID = "notebookVariablesView";
+    static readonly NOTEBOOK_TITLE: ILocalizedString;
+    static readonly REPL_TITLE: ILocalizedString;
+    private tree;
+    private activeNotebook;
+    private readonly dataSource;
+    private updateScheduler;
+    constructor(options: IViewPaneOptions, editorService: IEditorService, notebookKernelService: INotebookKernelService, notebookExecutionStateService: INotebookExecutionStateService, keybindingService: IKeybindingService, contextMenuService: IContextMenuService, contextKeyService: IContextKeyService, configurationService: IConfigurationService, instantiationService: IInstantiationService, viewDescriptorService: IViewDescriptorService, openerService: IOpenerService, quickInputService: IQuickInputService, commandService: ICommandService, themeService: IThemeService, telemetryService: ITelemetryService, hoverService: IHoverService, menuService: IMenuService);
+    protected renderBody(container: HTMLElement): void;
+    private onContextMenu;
+    focus(): void;
+    protected layoutBody(height: number, width: number): void;
+    private setActiveNotebook;
+    private getActiveNotebook;
+    private handleCloseEditor;
+    private handleActiveEditorChange;
+    private handleExecutionStateChange;
+    private handleVariablesChanged;
+}

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/notebookVariables/notebookVariablesView.js

@@ -1,7 +1,8 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { RunOnceScheduler } from 'vscode/vscode/vs/base/common/async';
 import { localize2 } from 'vscode/vscode/vs/nls';
-import { createAndFillInContextMenuActions } from 'vscode/vscode/vs/platform/actions/browser/menuEntryActionViewItem';
+import { getFlatContextMenuActions } from 'vscode/vscode/vs/platform/actions/browser/menuEntryActionViewItem';
 import { MenuId } from 'vscode/vscode/vs/platform/actions/common/actions';
 import { IMenuService } from 'vscode/vscode/vs/platform/actions/common/actions.service';
 import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands.service';
@@ -16,23 +17,23 @@ import { IOpenerService } from 'vscode/vscode/vs/platform/opener/common/opener.s
 import { IQuickInputService } from 'vscode/vscode/vs/platform/quickinput/common/quickInput.service';
 import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry.service';
 import { IThemeService } from 'vscode/vscode/vs/platform/theme/common/themeService.service';
-import { ViewPane } from 'vscode/vscode/vs/workbench/browser/parts/views/viewPane';
+import { ViewPane } from '@codingame/monaco-vscode-65619f8f-0eab-5d8b-855a-43b6353fe527-common/vscode/vs/workbench/browser/parts/views/viewPane';
 import { IViewDescriptorService } from 'vscode/vscode/vs/workbench/common/views.service';
 import { CONTEXT_VARIABLE_NAME, CONTEXT_VARIABLE_VALUE, CONTEXT_VARIABLE_TYPE, CONTEXT_VARIABLE_INTERFACES, CONTEXT_VARIABLE_LANGUAGE, CONTEXT_VARIABLE_EXTENSIONID } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
 import { NotebookVariableDataSource } from './notebookVariablesDataSource.js';
 import { NotebookVariablesDelegate, NotebookVariableRenderer, NotebookVariableAccessibilityProvider } from './notebookVariablesTree.js';
-import { getNotebookEditorFromEditorPane } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
+import { getNotebookEditorFromEditorPane } from '@codingame/monaco-vscode-271a23cd-c7d7-5761-ae35-a923a42987b8-common/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
 import { INotebookExecutionStateService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookExecutionStateService.service';
 import { INotebookKernelService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookKernelService.service';
 import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService.service';
-import { isCompositeNotebookEditorInput } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookEditorInput';
+import { isCompositeNotebookEditorInput } from '@codingame/monaco-vscode-271a23cd-c7d7-5761-ae35-a923a42987b8-common/vscode/vs/workbench/contrib/notebook/common/notebookEditorInput';
 
 var NotebookVariablesView_1;
 let NotebookVariablesView = class NotebookVariablesView extends ViewPane {
     static { NotebookVariablesView_1 = this; }
     static { this.ID = 'notebookVariablesView'; }
-    static { this.NOTEBOOK_TITLE = ( localize2(10995, "Notebook Variables")); }
-    static { this.REPL_TITLE = ( localize2(10996, "REPL Variables")); }
+    static { this.NOTEBOOK_TITLE = ( localize2(7382, "Notebook Variables")); }
+    static { this.REPL_TITLE = ( localize2(7383, "REPL Variables")); }
     constructor(options, editorService, notebookKernelService, notebookExecutionStateService, keybindingService, contextMenuService, contextKeyService, configurationService, instantiationService, viewDescriptorService, openerService, quickInputService, commandService, themeService, telemetryService, hoverService, menuService) {
         super(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService, hoverService);
         this.editorService = editorService;
@@ -46,14 +47,14 @@ let NotebookVariablesView = class NotebookVariablesView extends ViewPane {
         this._register(this.notebookExecutionStateService.onDidChangeExecution(this.handleExecutionStateChange.bind(this)));
         this._register(this.editorService.onDidCloseEditor((e) => this.handleCloseEditor(e)));
         this.handleActiveEditorChange(false);
-        this.dataSource = ( (new NotebookVariableDataSource(this.notebookKernelService)));
-        this.updateScheduler = ( (new RunOnceScheduler(() => this.tree?.updateChildren(), 100)));
+        this.dataSource = ( new NotebookVariableDataSource(this.notebookKernelService));
+        this.updateScheduler = ( new RunOnceScheduler(() => this.tree?.updateChildren(), 100));
     }
     renderBody(container) {
         super.renderBody(container);
         this.element.classList.add('debug-pane');
-        this.tree = this.instantiationService.createInstance(WorkbenchAsyncDataTree, 'notebookVariablesTree', container, ( (new NotebookVariablesDelegate())), [this.instantiationService.createInstance(NotebookVariableRenderer)], this.dataSource, {
-            accessibilityProvider: ( (new NotebookVariableAccessibilityProvider())),
+        this.tree = this.instantiationService.createInstance((WorkbenchAsyncDataTree), 'notebookVariablesTree', container, ( new NotebookVariablesDelegate()), [this.instantiationService.createInstance(NotebookVariableRenderer)], this.dataSource, {
+            accessibilityProvider: ( new NotebookVariableAccessibilityProvider()),
             identityProvider: { getId: (e) => e.id },
         });
         this.tree.layout();
@@ -68,7 +69,7 @@ let NotebookVariablesView = class NotebookVariablesView extends ViewPane {
         }
         const element = e.element;
         const arg = {
-            source: ( (element.notebook.uri.toString())),
+            source: ( element.notebook.uri.toString()),
             name: element.name,
             value: element.value,
             type: element.type,
@@ -76,7 +77,6 @@ let NotebookVariablesView = class NotebookVariablesView extends ViewPane {
             language: element.language,
             extensionId: element.extensionId
         };
-        const actions = [];
         const overlayedContext = this.contextKeyService.createOverlay([
             [CONTEXT_VARIABLE_NAME.key, element.name],
             [CONTEXT_VARIABLE_VALUE.key, element.value],
@@ -85,13 +85,17 @@ let NotebookVariablesView = class NotebookVariablesView extends ViewPane {
             [CONTEXT_VARIABLE_LANGUAGE.key, element.language],
             [CONTEXT_VARIABLE_EXTENSIONID.key, element.extensionId]
         ]);
-        const menu = this.menuService.getMenuActions(MenuId.NotebookVariablesContext, overlayedContext, { arg, shouldForwardArgs: true });
-        createAndFillInContextMenuActions(menu, actions);
+        const menuActions = this.menuService.getMenuActions(MenuId.NotebookVariablesContext, overlayedContext, { arg, shouldForwardArgs: true });
+        const actions = getFlatContextMenuActions(menuActions);
         this.contextMenuService.showContextMenu({
             getAnchor: () => e.anchor,
             getActions: () => actions
         });
     }
+    focus() {
+        super.focus();
+        this.tree?.domFocus();
+    }
     layoutBody(height, width) {
         super.layoutBody(height, width);
         this.tree?.layout(height, width);
@@ -115,7 +119,7 @@ let NotebookVariablesView = class NotebookVariablesView extends ViewPane {
         return notebookDocument && notebookEditor ? { notebookDocument, notebookEditor } : undefined;
     }
     handleCloseEditor(e) {
-        if (e.editor.resource && ( (e.editor.resource.toString())) === this.activeNotebook?.uri.toString()) {
+        if (e.editor.resource && ( e.editor.resource.toString()) === this.activeNotebook?.uri.toString()) {
             this.tree?.setInput({ kind: 'empty' });
             this.updateScheduler.schedule();
         }
@@ -146,36 +150,36 @@ let NotebookVariablesView = class NotebookVariablesView extends ViewPane {
         }
     }
     handleVariablesChanged(notebookUri) {
-        if (this.activeNotebook && ( (notebookUri.toString())) === ( (this.activeNotebook.uri.toString()))) {
+        if (this.activeNotebook && ( notebookUri.toString()) === ( this.activeNotebook.uri.toString())) {
             this.updateScheduler.schedule();
         }
         else if (!this.getActiveNotebook()) {
             this.editorService.visibleEditorPanes.forEach(editor => {
                 const notebookDocument = getNotebookEditorFromEditorPane(editor)?.textModel;
-                if (notebookDocument && ( (notebookDocument.uri.toString())) === ( (notebookUri.toString()))) {
+                if (notebookDocument && ( notebookDocument.uri.toString()) === ( notebookUri.toString())) {
                     this.setActiveNotebook(notebookDocument, editor);
                 }
             });
         }
     }
 };
-NotebookVariablesView = NotebookVariablesView_1 = ( (__decorate([
-    ( (__param(1, IEditorService))),
-    ( (__param(2, INotebookKernelService))),
-    ( (__param(3, INotebookExecutionStateService))),
-    ( (__param(4, IKeybindingService))),
-    ( (__param(5, IContextMenuService))),
-    ( (__param(6, IContextKeyService))),
-    ( (__param(7, IConfigurationService))),
-    ( (__param(8, IInstantiationService))),
-    ( (__param(9, IViewDescriptorService))),
-    ( (__param(10, IOpenerService))),
-    ( (__param(11, IQuickInputService))),
-    ( (__param(12, ICommandService))),
-    ( (__param(13, IThemeService))),
-    ( (__param(14, ITelemetryService))),
-    ( (__param(15, IHoverService))),
-    ( (__param(16, IMenuService)))
-], NotebookVariablesView)));
+NotebookVariablesView = NotebookVariablesView_1 = ( __decorate([
+    ( __param(1, IEditorService)),
+    ( __param(2, INotebookKernelService)),
+    ( __param(3, INotebookExecutionStateService)),
+    ( __param(4, IKeybindingService)),
+    ( __param(5, IContextMenuService)),
+    ( __param(6, IContextKeyService)),
+    ( __param(7, IConfigurationService)),
+    ( __param(8, IInstantiationService)),
+    ( __param(9, IViewDescriptorService)),
+    ( __param(10, IOpenerService)),
+    ( __param(11, IQuickInputService)),
+    ( __param(12, ICommandService)),
+    ( __param(13, IThemeService)),
+    ( __param(14, ITelemetryService)),
+    ( __param(15, IHoverService)),
+    ( __param(16, IMenuService))
+], NotebookVariablesView));
 
 export { NotebookVariablesView };

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/outline/notebookOutline.d.ts

@@ -0,0 +1,112 @@
+import { IDataSource } from "vscode/vscode/vs/base/browser/ui/tree/tree";
+import { Event } from "vscode/vscode/vs/base/common/event";
+import { IDisposable, type IReference } from "vscode/vscode/vs/base/common/lifecycle";
+import { URI } from "vscode/vscode/vs/base/common/uri";
+import { IConfigurationService } from "vscode/vscode/vs/platform/configuration/common/configuration.service";
+import { IEditorOptions } from "vscode/vscode/vs/platform/editor/common/editor";
+import { IInstantiationService } from "vscode/vscode/vs/platform/instantiation/common/instantiation";
+import { IThemeService } from "vscode/vscode/vs/platform/theme/common/themeService.service";
+import { IEditorPane } from "vscode/vscode/vs/workbench/common/editor";
+import { CellFoldingState, INotebookEditorPane } from "@codingame/monaco-vscode-271a23cd-c7d7-5761-ae35-a923a42987b8-common/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser";
+import { NotebookEditor } from "@codingame/monaco-vscode-6f9bc782-77e0-5716-93bd-b05210c768c5-common/vscode/vs/workbench/contrib/notebook/browser/notebookEditor";
+import { INotebookCellOutlineDataSource } from "@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/notebook/browser/viewModel/notebookOutlineDataSource";
+import { CellKind } from "vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon";
+import { IEditorService } from "vscode/vscode/vs/workbench/services/editor/common/editorService.service";
+import { IBreadcrumbsDataSource, IOutline, IOutlineCreator, IOutlineListConfig, IQuickPickDataSource, IQuickPickOutlineElement, OutlineChangeEvent, OutlineTarget } from "@codingame/monaco-vscode-d6e33d82-c101-549d-a885-0807ab3e0cfb-common/vscode/vs/workbench/services/outline/browser/outline";
+import { IOutlineService } from "vscode/vscode/vs/workbench/services/outline/browser/outline.service";
+import { OutlineEntry } from "@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/notebook/browser/viewModel/OutlineEntry";
+import { CancellationToken } from "vscode/vscode/vs/base/common/cancellation";
+import { RawContextKey } from "vscode/vscode/vs/platform/contextkey/common/contextkey";
+import { INotebookExecutionStateService } from "vscode/vscode/vs/workbench/contrib/notebook/common/notebookExecutionStateService.service";
+import { ILanguageFeaturesService } from "vscode/vscode/vs/editor/common/services/languageFeatures";
+export declare class NotebookQuickPickProvider implements IQuickPickDataSource<OutlineEntry> {
+    private readonly notebookCellOutlineDataSourceRef;
+    private readonly _configurationService;
+    private readonly _themeService;
+    private readonly _disposables;
+    private gotoShowCodeCellSymbols;
+    constructor(notebookCellOutlineDataSourceRef: IReference<INotebookCellOutlineDataSource> | undefined, _configurationService: IConfigurationService, _themeService: IThemeService);
+    getQuickPickElements(): IQuickPickOutlineElement<OutlineEntry>[];
+    dispose(): void;
+}
+export declare class NotebookOutlinePaneProvider implements IDataSource<NotebookCellOutline, OutlineEntry> {
+    private readonly outlineDataSourceRef;
+    private readonly _configurationService;
+    private readonly _disposables;
+    private showCodeCells;
+    private showCodeCellSymbols;
+    private showMarkdownHeadersOnly;
+    constructor(outlineDataSourceRef: IReference<INotebookCellOutlineDataSource> | undefined, _configurationService: IConfigurationService);
+    getActiveEntry(): OutlineEntry | undefined;
+    private filterEntry;
+    getChildren(element: NotebookCellOutline | OutlineEntry): Iterable<OutlineEntry>;
+    dispose(): void;
+}
+export declare class NotebookBreadcrumbsProvider implements IBreadcrumbsDataSource<OutlineEntry> {
+    private readonly outlineDataSourceRef;
+    private readonly _configurationService;
+    private readonly _disposables;
+    private showCodeCells;
+    constructor(outlineDataSourceRef: IReference<INotebookCellOutlineDataSource> | undefined, _configurationService: IConfigurationService);
+    getBreadcrumbElements(): readonly OutlineEntry[];
+    dispose(): void;
+}
+export declare class NotebookCellOutline implements IOutline<OutlineEntry> {
+    private readonly _editor;
+    private readonly _target;
+    private readonly _themeService;
+    private readonly _editorService;
+    private readonly _instantiationService;
+    private readonly _configurationService;
+    private readonly _languageFeaturesService;
+    private readonly _notebookExecutionStateService;
+    readonly outlineKind = "notebookCells";
+    private readonly _disposables;
+    private readonly _modelDisposables;
+    private readonly _dataSourceDisposables;
+    private readonly _onDidChange;
+    readonly onDidChange: Event<OutlineChangeEvent>;
+    private readonly delayerRecomputeState;
+    private readonly delayerRecomputeActive;
+    private readonly delayerRecomputeSymbols;
+    readonly config: IOutlineListConfig<OutlineEntry>;
+    private _outlineDataSourceReference;
+    private _treeDataSource;
+    private _quickPickDataSource;
+    private _breadcrumbsDataSource;
+    private outlineShowCodeCellSymbols;
+    get activeElement(): OutlineEntry | undefined;
+    get entries(): OutlineEntry[];
+    get uri(): URI | undefined;
+    get isEmpty(): boolean;
+    private checkDelayer;
+    constructor(_editor: INotebookEditorPane, _target: OutlineTarget, _themeService: IThemeService, _editorService: IEditorService, _instantiationService: IInstantiationService, _configurationService: IConfigurationService, _languageFeaturesService: ILanguageFeaturesService, _notebookExecutionStateService: INotebookExecutionStateService);
+    private initializeOutline;
+    private setDataSources;
+    private setModelListeners;
+    private computeSymbols;
+    doComputeSymbols(cancelToken: CancellationToken): Promise<void>;
+    private delayedComputeSymbols;
+    private recomputeState;
+    private delayedRecomputeState;
+    private recomputeActive;
+    private delayedRecomputeActive;
+    reveal(entry: OutlineEntry, options: IEditorOptions, sideBySide: boolean): Promise<void>;
+    preview(entry: OutlineEntry): IDisposable;
+    captureViewState(): IDisposable;
+    dispose(): void;
+}
+export declare class NotebookOutlineCreator implements IOutlineCreator<NotebookEditor, OutlineEntry> {
+    private readonly _instantiationService;
+    readonly dispose: () => void;
+    constructor(outlineService: IOutlineService, _instantiationService: IInstantiationService);
+    matches(candidate: IEditorPane): candidate is NotebookEditor;
+    createOutline(editor: INotebookEditorPane, target: OutlineTarget, cancelToken: CancellationToken): Promise<IOutline<OutlineEntry> | undefined>;
+}
+export declare const NotebookOutlineContext: {
+    CellKind: RawContextKey<CellKind>;
+    CellHasChildren: RawContextKey<boolean>;
+    CellHasHeader: RawContextKey<boolean>;
+    CellFoldingState: RawContextKey<CellFoldingState>;
+    OutlineElementTarget: RawContextKey<OutlineTarget>;
+};