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

package/vscode/src/vs/workbench/contrib/notebook/browser/services/notebookKernelServiceImpl.js

@@ -1,13 +1,16 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { Emitter } from 'vscode/vscode/vs/base/common/event';
 import { Disposable, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
 import { ResourceMap, LRUCache } from 'vscode/vscode/vs/base/common/map';
+import { StorageScope, StorageTarget } from 'vscode/vscode/vs/platform/storage/common/storage';
 import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
 import { URI } from 'vscode/vscode/vs/base/common/uri';
 import { INotebookService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookService.service';
 import { MenuId } from 'vscode/vscode/vs/platform/actions/common/actions';
 import { IMenuService } from 'vscode/vscode/vs/platform/actions/common/actions.service';
 import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey.service';
+import { MarshalledId } from 'vscode/vscode/vs/base/common/marshallingIds';
 import { Schemas } from 'vscode/vscode/vs/base/common/network';
 import { runWhenWindowIdle, getActiveWindow } from 'vscode/vscode/vs/base/browser/dom';
 
@@ -56,7 +59,7 @@ class SourceAction extends Disposable {
         try {
             await this.action.run({
                 uri: this.model.uri,
-                $mid: 14
+                $mid: MarshalledId.NotebookActionContext
             });
         }
         catch (error) {
@@ -104,7 +107,7 @@ let NotebookKernelService = class NotebookKernelService extends Disposable {
             this._kernelSourceActionsUpdates.delete(id);
         }));
         try {
-            const data = JSON.parse(this._storageService.get(NotebookKernelService_1._storageNotebookBinding, 1 , '[]'));
+            const data = JSON.parse(this._storageService.get(NotebookKernelService_1._storageNotebookBinding, StorageScope.WORKSPACE, '[]'));
             this._notebookBindings.fromJSON(data);
         }
         catch {
@@ -125,7 +128,7 @@ let NotebookKernelService = class NotebookKernelService extends Disposable {
     _persistMementos() {
         this._persistSoonHandle?.dispose();
         this._persistSoonHandle = runWhenWindowIdle(getActiveWindow(), () => {
-            this._storageService.store(NotebookKernelService_1._storageNotebookBinding, JSON.stringify(this._notebookBindings), 1 , 1 );
+            this._storageService.store(NotebookKernelService_1._storageNotebookBinding, JSON.stringify(this._notebookBindings), StorageScope.WORKSPACE, StorageTarget.MACHINE);
         }, 100);
     }
     static _score(kernel, notebook) {

package/vscode/src/vs/workbench/contrib/notebook/browser/services/notebookKeymapServiceImpl.d.ts

@@ -0,0 +1,20 @@
+import { Disposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { IInstantiationService } from "vscode/vscode/vs/platform/instantiation/common/instantiation";
+import { INotificationService } from "vscode/vscode/vs/platform/notification/common/notification.service";
+import { IExtensionStatus } from "@codingame/monaco-vscode-3a00040f-b81b-50bc-88da-35f611c0bd1e-common/vscode/vs/workbench/contrib/extensions/common/extensionsUtils";
+import { INotebookKeymapService } from "vscode/vscode/vs/workbench/contrib/notebook/common/notebookKeymapService.service";
+import { IWorkbenchExtensionEnablementService } from "vscode/vscode/vs/workbench/services/extensionManagement/common/extensionManagement.service";
+import { ILifecycleService } from "vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle.service";
+import { IStorageService } from "vscode/vscode/vs/platform/storage/common/storage.service";
+export declare class NotebookKeymapService extends Disposable implements INotebookKeymapService {
+    private readonly instantiationService;
+    private readonly extensionEnablementService;
+    private readonly notificationService;
+    _serviceBrand: undefined;
+    private notebookKeymapMemento;
+    private notebookKeymap;
+    constructor(instantiationService: IInstantiationService, extensionEnablementService: IWorkbenchExtensionEnablementService, notificationService: INotificationService, storageService: IStorageService, lifecycleService: ILifecycleService);
+    private checkForOtherKeymaps;
+    private promptForDisablingOtherKeymaps;
+}
+export declare function isNotebookKeymapExtension(extension: IExtensionStatus): boolean;

package/vscode/src/vs/workbench/contrib/notebook/browser/services/notebookKeymapServiceImpl.js

@@ -1,4 +1,5 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { onUnexpectedError } from 'vscode/vscode/vs/base/common/errors';
 import { Event } from 'vscode/vscode/vs/base/common/event';
 import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
@@ -6,28 +7,31 @@ import { localize } from 'vscode/vscode/vs/nls';
 import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
 import 'vscode/vscode/vs/platform/notification/common/notification';
 import { INotificationService } from 'vscode/vscode/vs/platform/notification/common/notification.service';
-import { getInstalledExtensions } from 'vscode/vscode/vs/workbench/contrib/extensions/common/extensionsUtils';
+import { getInstalledExtensions } from '@codingame/monaco-vscode-3a00040f-b81b-50bc-88da-35f611c0bd1e-common/vscode/vs/workbench/contrib/extensions/common/extensionsUtils';
+import { EnablementState } from 'vscode/vscode/vs/workbench/services/extensionManagement/common/extensionManagement';
 import { IWorkbenchExtensionEnablementService } from 'vscode/vscode/vs/workbench/services/extensionManagement/common/extensionManagement.service';
 import { ILifecycleService } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle.service';
+import { InstallOperation } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagement';
 import { IExtensionManagementService } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagement.service';
 import { areSameExtensions } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagementUtil';
+import { StorageScope, StorageTarget } from 'vscode/vscode/vs/platform/storage/common/storage';
 import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
-import { Memento } from 'vscode/vscode/vs/workbench/common/memento';
+import { Memento } from '@codingame/monaco-vscode-9e888134-1a6f-58d9-b0e6-0fc047448366-common/vscode/vs/workbench/common/memento';
 import { distinct } from 'vscode/vscode/vs/base/common/arrays';
-import Severity$1 from 'vscode/vscode/vs/base/common/severity';
+import Severity from 'vscode/vscode/vs/base/common/severity';
 
 function onExtensionChanged(accessor) {
     const extensionService = accessor.get(IExtensionManagementService);
     const extensionEnablementService = accessor.get(IWorkbenchExtensionEnablementService);
-    const onDidInstallExtensions = Event.chain(extensionService.onDidInstallExtensions, $ => ( ($.filter(e => ( (e.some(({ operation }) => operation === 2 ))))
-        .map(e => ( (e.map(({ identifier }) => identifier)))))));
-    return Event.debounce(Event.any(Event.any(onDidInstallExtensions, ( (Event.map(extensionService.onDidUninstallExtension, e => [e.identifier])))), ( (Event.map(
+    const onDidInstallExtensions = Event.chain(extensionService.onDidInstallExtensions, $ => ( $.filter(e => ( e.some(({ operation }) => operation === InstallOperation.Install)))
+        .map(e => ( e.map(({ identifier }) => identifier)))));
+    return Event.debounce(Event.any(Event.any(onDidInstallExtensions, ( Event.map(extensionService.onDidUninstallExtension, e => [e.identifier]))), ( Event.map(
         extensionEnablementService.onEnablementChanged,
-        extensions => ( (extensions.map(e => e.identifier)))
-    )))), (result, identifiers) => {
+        extensions => ( extensions.map(e => e.identifier))
+    ))), (result, identifiers) => {
         result = result || (identifiers.length ? [identifiers[0]] : []);
         for (const identifier of identifiers) {
-            if (( (result.some(l => !areSameExtensions(l, identifier))))) {
+            if (( result.some(l => !areSameExtensions(l, identifier)))) {
                 result.push(identifier);
             }
         }
@@ -41,11 +45,11 @@ let NotebookKeymapService = class NotebookKeymapService extends Disposable {
         this.instantiationService = instantiationService;
         this.extensionEnablementService = extensionEnablementService;
         this.notificationService = notificationService;
-        this.notebookKeymapMemento = ( (new Memento('notebookKeymap', storageService)));
-        this.notebookKeymap = this.notebookKeymapMemento.getMemento(0 , 0 );
+        this.notebookKeymapMemento = ( new Memento('notebookKeymap', storageService));
+        this.notebookKeymap = this.notebookKeymapMemento.getMemento(StorageScope.PROFILE, StorageTarget.USER);
         this._register(lifecycleService.onDidShutdown(() => this.dispose()));
         this._register(this.instantiationService.invokeFunction(onExtensionChanged)((identifiers => {
-            Promise.all(( (identifiers.map(identifier => this.checkForOtherKeymaps(identifier)))))
+            Promise.all(( identifiers.map(identifier => this.checkForOtherKeymaps(identifier))))
                 .then(undefined, onUnexpectedError);
         })));
     }
@@ -67,29 +71,29 @@ let NotebookKeymapService = class NotebookKeymapService extends Disposable {
     promptForDisablingOtherKeymaps(newKeymap, oldKeymaps) {
         const onPrompt = (confirmed) => {
             if (confirmed) {
-                this.extensionEnablementService.setEnablement(( (oldKeymaps.map(keymap => keymap.local))), 7 );
+                this.extensionEnablementService.setEnablement(( oldKeymaps.map(keymap => keymap.local)), EnablementState.DisabledGlobally);
             }
         };
-        this.notificationService.prompt(Severity$1.Info, ( localize(
-            3294,
+        this.notificationService.prompt(Severity.Info, ( localize(
+            7744,
             "Disable other keymaps ({0}) to avoid conflicts between keybindings?",
-            ( (distinct(( (oldKeymaps.map(k => k.local.manifest.displayName)))).map(name => `'${name}'`))).join(', ')
+            ( distinct(( oldKeymaps.map(k => k.local.manifest.displayName))).map(name => `'${name}'`)).join(', ')
         )), [{
-                label: ( localize(3295, "Yes")),
+                label: ( localize(7745, "Yes")),
                 run: () => onPrompt(true)
             }, {
-                label: ( localize(3296, "No")),
+                label: ( localize(7746, "No")),
                 run: () => onPrompt(false)
             }]);
     }
 };
-NotebookKeymapService = ( (__decorate([
-    ( (__param(0, IInstantiationService))),
-    ( (__param(1, IWorkbenchExtensionEnablementService))),
-    ( (__param(2, INotificationService))),
-    ( (__param(3, IStorageService))),
-    ( (__param(4, ILifecycleService)))
-], NotebookKeymapService)));
+NotebookKeymapService = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, IWorkbenchExtensionEnablementService)),
+    ( __param(2, INotificationService)),
+    ( __param(3, IStorageService)),
+    ( __param(4, ILifecycleService))
+], NotebookKeymapService));
 function isNotebookKeymapExtension(extension) {
     if (extension.local.manifest.extensionPack) {
         return false;

package/vscode/src/vs/workbench/contrib/notebook/browser/services/notebookLoggingServiceImpl.d.ts

@@ -0,0 +1,13 @@
+import { Disposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { INotebookLoggingService } from "vscode/vscode/vs/workbench/contrib/notebook/common/notebookLoggingService.service";
+import { ILoggerService } from "vscode/vscode/vs/platform/log/common/log.service";
+export declare class NotebookLoggingService extends Disposable implements INotebookLoggingService {
+    _serviceBrand: undefined;
+    static ID: string;
+    private readonly _logger;
+    constructor(loggerService: ILoggerService);
+    debug(category: string, output: string): void;
+    info(category: string, output: string): void;
+    warn(category: string, output: string): void;
+    error(category: string, output: string): void;
+}

package/vscode/src/vs/workbench/contrib/notebook/browser/services/notebookLoggingServiceImpl.js

@@ -1,4 +1,5 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { localize } from 'vscode/vscode/vs/nls';
 import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
 import { ILoggerService } from 'vscode/vscode/vs/platform/log/common/log.service';
@@ -8,7 +9,7 @@ let NotebookLoggingService = class NotebookLoggingService extends Disposable {
     static { this.ID = 'notebook'; }
     constructor(loggerService) {
         super();
-        this._logger = this._register(loggerService.createLogger(logChannelId, { name: ( localize(3298, "Notebook")) }));
+        this._logger = this._register(loggerService.createLogger(logChannelId, { name: ( localize(7747, "Notebook")) }));
     }
     debug(category, output) {
         this._logger.debug(`[${category}] ${output}`);
@@ -23,8 +24,8 @@ let NotebookLoggingService = class NotebookLoggingService extends Disposable {
         this._logger.error(`[${category}] ${output}`);
     }
 };
-NotebookLoggingService = ( (__decorate([
-    ( (__param(0, ILoggerService)))
-], NotebookLoggingService)));
+NotebookLoggingService = ( __decorate([
+    ( __param(0, ILoggerService))
+], NotebookLoggingService));
 
 export { NotebookLoggingService };

package/vscode/src/vs/workbench/contrib/notebook/browser/services/notebookRendererMessagingServiceImpl.d.ts

@@ -0,0 +1,23 @@
+import { Disposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { IScopedRendererMessaging } from "vscode/vscode/vs/workbench/contrib/notebook/common/notebookRendererMessagingService";
+import { INotebookRendererMessagingService } from "vscode/vscode/vs/workbench/contrib/notebook/common/notebookRendererMessagingService.service";
+import { IExtensionService } from "vscode/vscode/vs/workbench/services/extensions/common/extensions.service";
+type MessageToSend = {
+    editorId: string;
+    rendererId: string;
+    message: unknown;
+};
+export declare class NotebookRendererMessagingService extends Disposable implements INotebookRendererMessagingService {
+    private readonly extensionService;
+    _serviceBrand: undefined;
+    private readonly activations;
+    private readonly scopedMessaging;
+    private readonly postMessageEmitter;
+    readonly onShouldPostMessage: import("vscode/vscode/vs/base/common/event").Event<MessageToSend>;
+    constructor(extensionService: IExtensionService);
+    receiveMessage(editorId: string | undefined, rendererId: string, message: unknown): Promise<boolean>;
+    prepare(rendererId: string): void;
+    getScoped(editorId: string): IScopedRendererMessaging;
+    private postMessage;
+}
+export {};

package/vscode/src/vs/workbench/contrib/notebook/browser/services/notebookRendererMessagingServiceImpl.js

@@ -1,4 +1,5 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { Emitter } from 'vscode/vscode/vs/base/common/event';
 import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
 import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions.service';

package/vscode/src/vs/workbench/contrib/notebook/browser/services/notebookServiceImpl.d.ts

@@ -0,0 +1,134 @@
+import { Event } from "vscode/vscode/vs/base/common/event";
+import { Disposable, IDisposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { URI } from "vscode/vscode/vs/base/common/uri";
+import { IAccessibilityService } from "vscode/vscode/vs/platform/accessibility/common/accessibility.service";
+import { ConfigurationTarget } from "vscode/vscode/vs/platform/configuration/common/configuration";
+import { IConfigurationService } from "vscode/vscode/vs/platform/configuration/common/configuration.service";
+import { IFileService } from "vscode/vscode/vs/platform/files/common/files.service";
+import { IInstantiationService } from "vscode/vscode/vs/platform/instantiation/common/instantiation";
+import { IStorageService } from "vscode/vscode/vs/platform/storage/common/storage.service";
+import { NotebookCellTextModel } from "@codingame/monaco-vscode-c465110a-57c0-59d7-a6b2-be0a4db7e517-common/vscode/vs/workbench/contrib/notebook/common/model/notebookCellTextModel";
+import { NotebookTextModel } from "../../common/model/notebookTextModel.js";
+import { INotebookContributionData, INotebookRendererInfo, IOrderedMimeType, IOutputDto, NotebookExtensionDescription, INotebookStaticPreloadInfo } from "vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon";
+import { INotebookEditorModelResolverService } from "vscode/vscode/vs/workbench/contrib/notebook/common/notebookEditorModelResolverService.service";
+import { NotebookOutputRendererInfo } from "../../common/notebookOutputRenderer.js";
+import { NotebookProviderInfo } from "../../common/notebookProvider.js";
+import { INotebookSerializer, SimpleNotebookProviderInfo } from "@codingame/monaco-vscode-271a23cd-c7d7-5761-ae35-a923a42987b8-common/vscode/vs/workbench/contrib/notebook/common/notebookService";
+import { INotebookService } from "vscode/vscode/vs/workbench/contrib/notebook/common/notebookService.service";
+import { IEditorType } from "vscode/vscode/vs/workbench/services/editor/common/editorResolverService";
+import { IEditorResolverService } from "vscode/vscode/vs/workbench/services/editor/common/editorResolverService.service";
+import { IExtensionService } from "vscode/vscode/vs/workbench/services/extensions/common/extensions.service";
+import { IUriIdentityService } from "vscode/vscode/vs/platform/uriIdentity/common/uriIdentity.service";
+import { INotebookDocumentService } from "vscode/vscode/vs/workbench/services/notebook/common/notebookDocumentService.service";
+import { VSBufferReadableStream } from "vscode/vscode/vs/base/common/buffer";
+import { SnapshotContext } from "@codingame/monaco-vscode-9d05a43d-c330-5ff1-937e-fde4a3852931-common/vscode/vs/workbench/services/workingCopy/common/fileWorkingCopy";
+import { CancellationToken } from "vscode/vscode/vs/base/common/cancellation";
+export declare class NotebookProviderInfoStore extends Disposable {
+    private readonly _editorResolverService;
+    private readonly _configurationService;
+    private readonly _accessibilityService;
+    private readonly _instantiationService;
+    private readonly _fileService;
+    private readonly _notebookEditorModelResolverService;
+    private readonly uriIdentService;
+    private static readonly CUSTOM_EDITORS_STORAGE_ID;
+    private static readonly CUSTOM_EDITORS_ENTRY_ID;
+    private readonly _memento;
+    private _handled;
+    private readonly _contributedEditors;
+    private readonly _contributedEditorDisposables;
+    constructor(storageService: IStorageService, extensionService: IExtensionService, _editorResolverService: IEditorResolverService, _configurationService: IConfigurationService, _accessibilityService: IAccessibilityService, _instantiationService: IInstantiationService, _fileService: IFileService, _notebookEditorModelResolverService: INotebookEditorModelResolverService, uriIdentService: IUriIdentityService);
+    dispose(): void;
+    private _setupHandler;
+    clearEditorCache(): void;
+    private _convertPriority;
+    private _registerContributionPoint;
+    private _clear;
+    get(viewType: string): NotebookProviderInfo | undefined;
+    add(info: NotebookProviderInfo, saveMemento?: boolean): IDisposable;
+    getContributedNotebook(resource: URI): readonly NotebookProviderInfo[];
+    [Symbol.iterator](): Iterator<NotebookProviderInfo>;
+}
+export declare class NotebookOutputRendererInfoStore {
+    private readonly contributedRenderers;
+    private readonly preferredMimetypeMemento;
+    private readonly preferredMimetype;
+    constructor(storageService: IStorageService);
+    clear(): void;
+    get(rendererId: string): NotebookOutputRendererInfo | undefined;
+    getAll(): NotebookOutputRendererInfo[];
+    add(info: NotebookOutputRendererInfo): void;
+    setPreferred(notebookProviderInfo: NotebookProviderInfo, mimeType: string, rendererId: string): void;
+    findBestRenderers(notebookProviderInfo: NotebookProviderInfo | undefined, mimeType: string, kernelProvides: readonly string[] | undefined): IOrderedMimeType[];
+}
+export declare class NotebookService extends Disposable implements INotebookService {
+    private readonly _extensionService;
+    private readonly _configurationService;
+    private readonly _accessibilityService;
+    private readonly _instantiationService;
+    private readonly _storageService;
+    private readonly _notebookDocumentService;
+    readonly _serviceBrand: undefined;
+    private static _storageNotebookViewTypeProvider;
+    private readonly _memento;
+    private readonly _viewTypeCache;
+    private readonly _notebookProviders;
+    private _notebookProviderInfoStore;
+    private get notebookProviderInfoStore();
+    private readonly _notebookRenderersInfoStore;
+    private readonly _onDidChangeOutputRenderers;
+    readonly onDidChangeOutputRenderers: Event<void>;
+    private readonly _notebookStaticPreloadInfoStore;
+    private readonly _models;
+    private readonly _onWillAddNotebookDocument;
+    private readonly _onDidAddNotebookDocument;
+    private readonly _onWillRemoveNotebookDocument;
+    private readonly _onDidRemoveNotebookDocument;
+    readonly onWillAddNotebookDocument: Event<NotebookTextModel>;
+    readonly onDidAddNotebookDocument: Event<NotebookTextModel>;
+    readonly onDidRemoveNotebookDocument: Event<NotebookTextModel>;
+    readonly onWillRemoveNotebookDocument: Event<NotebookTextModel>;
+    private readonly _onAddViewType;
+    readonly onAddViewType: Event<string>;
+    private readonly _onWillRemoveViewType;
+    readonly onWillRemoveViewType: Event<string>;
+    private readonly _onDidChangeEditorTypes;
+    onDidChangeEditorTypes: Event<void>;
+    private _cutItems;
+    private _lastClipboardIsCopy;
+    private _displayOrder;
+    constructor(_extensionService: IExtensionService, _configurationService: IConfigurationService, _accessibilityService: IAccessibilityService, _instantiationService: IInstantiationService, _storageService: IStorageService, _notebookDocumentService: INotebookDocumentService);
+    getEditorTypes(): IEditorType[];
+    clearEditorCache(): void;
+    private _postDocumentOpenActivation;
+    canResolve(viewType: string): Promise<boolean>;
+    registerContributedNotebookType(viewType: string, data: INotebookContributionData): IDisposable;
+    private _registerProviderData;
+    registerNotebookSerializer(viewType: string, extensionData: NotebookExtensionDescription, serializer: INotebookSerializer): IDisposable;
+    withNotebookDataProvider(viewType: string): Promise<SimpleNotebookProviderInfo>;
+    tryGetDataProviderSync(viewType: string): SimpleNotebookProviderInfo | undefined;
+    private _persistMementos;
+    getViewTypeProvider(viewType: string): string | undefined;
+    getRendererInfo(rendererId: string): INotebookRendererInfo | undefined;
+    updateMimePreferredRenderer(viewType: string, mimeType: string, rendererId: string, otherMimetypes: readonly string[]): void;
+    saveMimeDisplayOrder(target: ConfigurationTarget): void;
+    getRenderers(): INotebookRendererInfo[];
+    getStaticPreloads(viewType: string): Iterable<INotebookStaticPreloadInfo>;
+    createNotebookTextModel(viewType: string, uri: URI, stream?: VSBufferReadableStream): Promise<NotebookTextModel>;
+    createNotebookTextDocumentSnapshot(uri: URI, context: SnapshotContext, token: CancellationToken): Promise<VSBufferReadableStream>;
+    restoreNotebookTextModelFromSnapshot(uri: URI, viewType: string, snapshot: VSBufferReadableStream): Promise<NotebookTextModel>;
+    getNotebookTextModel(uri: URI): NotebookTextModel | undefined;
+    getNotebookTextModels(): Iterable<NotebookTextModel>;
+    listNotebookDocuments(): NotebookTextModel[];
+    private _onWillDisposeDocument;
+    getOutputMimeTypeInfo(textModel: NotebookTextModel, kernelProvides: readonly string[] | undefined, output: IOutputDto): readonly IOrderedMimeType[];
+    getContributedNotebookTypes(resource?: URI): readonly NotebookProviderInfo[];
+    hasSupportedNotebooks(resource: URI): boolean;
+    getContributedNotebookType(viewType: string): NotebookProviderInfo | undefined;
+    getNotebookProviderResourceRoots(): URI[];
+    setToCopy(items: NotebookCellTextModel[], isCopy: boolean): void;
+    getToCopy(): {
+        items: NotebookCellTextModel[];
+        isCopy: boolean;
+    } | undefined;
+}