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

package/vscode/src/vs/workbench/contrib/notebook/common/notebookEditorModelResolverServiceImpl.js

@@ -1,8 +1,9 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
 import { URI } from 'vscode/vscode/vs/base/common/uri';
 import { NotebookWorkingCopyTypeIdentifier, NotebookSetting, CellUri } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
-import { NotebookFileWorkingCopyModelFactory, SimpleNotebookEditorModel } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookEditorModel';
+import { NotebookFileWorkingCopyModelFactory, SimpleNotebookEditorModel } from '@codingame/monaco-vscode-99f24462-c56d-5407-83fb-2ea9dd33cc8c-common/vscode/vs/workbench/contrib/notebook/common/notebookEditorModel';
 import { ReferenceCollection, DisposableStore, dispose, combinedDisposable, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
 import { INotebookService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookService.service';
 import { Emitter, AsyncEmitter } from 'vscode/vscode/vs/base/common/event';
@@ -59,7 +60,7 @@ let NotebookModelReferenceCollection = class NotebookModelReferenceCollection ex
                 this._telemetryService,
                 this._notebookLoggingService
             ));
-            workingCopyManager = this._instantiationService.createInstance(FileWorkingCopyManager, workingCopyTypeId, factory, factory);
+            workingCopyManager = this._instantiationService.createInstance((FileWorkingCopyManager), workingCopyTypeId, factory, factory);
             this._workingCopyManagers.set(workingCopyTypeId, workingCopyManager);
         }
         const isScratchpadView = isScratchpad || (notebookType === 'interactive' && this._configurationService.getValue(NotebookSetting.InteractiveWindowPromptToSave) !== true);

package/vscode/src/vs/workbench/contrib/notebook/common/notebookOutputRenderer.d.ts

@@ -0,0 +1,48 @@
+import { URI } from "vscode/vscode/vs/base/common/uri";
+import { ExtensionIdentifier, IExtensionDescription } from "vscode/vscode/vs/platform/extensions/common/extensions";
+import { INotebookRendererInfo, ContributedNotebookRendererEntrypoint, NotebookRendererMatch, RendererMessagingSpec, NotebookRendererEntrypoint, INotebookStaticPreloadInfo as INotebookStaticPreloadInfo } from "vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon";
+declare class DependencyList {
+    private readonly value;
+    readonly defined: boolean;
+    constructor(value: Iterable<string>);
+    matches(available: ReadonlyArray<string>): boolean;
+}
+export declare class NotebookOutputRendererInfo implements INotebookRendererInfo {
+    readonly id: string;
+    readonly entrypoint: NotebookRendererEntrypoint;
+    readonly displayName: string;
+    readonly extensionLocation: URI;
+    readonly extensionId: ExtensionIdentifier;
+    readonly hardDependencies: DependencyList;
+    readonly optionalDependencies: DependencyList;
+    readonly messaging: RendererMessagingSpec;
+    readonly mimeTypes: readonly string[];
+    private readonly mimeTypeGlobs;
+    readonly isBuiltin: boolean;
+    constructor(descriptor: {
+        readonly id: string;
+        readonly displayName: string;
+        readonly entrypoint: ContributedNotebookRendererEntrypoint;
+        readonly mimeTypes: readonly string[];
+        readonly extension: IExtensionDescription;
+        readonly dependencies: readonly string[] | undefined;
+        readonly optionalDependencies: readonly string[] | undefined;
+        readonly requiresMessaging: RendererMessagingSpec | undefined;
+    });
+    matchesWithoutKernel(mimeType: string): NotebookRendererMatch;
+    matches(mimeType: string, kernelProvides: ReadonlyArray<string>): NotebookRendererMatch;
+    private matchesMimeTypeOnly;
+}
+export declare class NotebookStaticPreloadInfo implements INotebookStaticPreloadInfo {
+    readonly type: string;
+    readonly entrypoint: URI;
+    readonly extensionLocation: URI;
+    readonly localResourceRoots: readonly URI[];
+    constructor(descriptor: {
+        readonly type: string;
+        readonly entrypoint: string;
+        readonly localResourceRoots: readonly string[];
+        readonly extension: IExtensionDescription;
+    });
+}
+export {};

package/vscode/src/vs/workbench/contrib/notebook/common/notebookOutputRenderer.js

@@ -1,6 +1,8 @@
+
 import { parse } from 'vscode/vscode/vs/base/common/glob';
 import { Iterable } from 'vscode/vscode/vs/base/common/iterator';
 import { joinPath } from 'vscode/vscode/vs/base/common/resources';
+import { RendererMessagingSpec, NotebookRendererMatch } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
 
 class DependencyList {
     constructor(value) {
@@ -34,32 +36,32 @@ class NotebookOutputRendererInfo {
         this.mimeTypeGlobs = ( this.mimeTypes.map(pattern => parse(pattern)));
         this.hardDependencies = ( new DependencyList(descriptor.dependencies ?? Iterable.empty()));
         this.optionalDependencies = ( new DependencyList(descriptor.optionalDependencies ?? Iterable.empty()));
-        this.messaging = descriptor.requiresMessaging ?? "never" ;
+        this.messaging = descriptor.requiresMessaging ?? RendererMessagingSpec.Never;
     }
     matchesWithoutKernel(mimeType) {
         if (!this.matchesMimeTypeOnly(mimeType)) {
-            return 3 ;
+            return NotebookRendererMatch.Never;
         }
         if (this.hardDependencies.defined) {
-            return 0 ;
+            return NotebookRendererMatch.WithHardKernelDependency;
         }
         if (this.optionalDependencies.defined) {
-            return 1 ;
+            return NotebookRendererMatch.WithOptionalKernelDependency;
         }
-        return 2 ;
+        return NotebookRendererMatch.Pure;
     }
     matches(mimeType, kernelProvides) {
         if (!this.matchesMimeTypeOnly(mimeType)) {
-            return 3 ;
+            return NotebookRendererMatch.Never;
         }
         if (this.hardDependencies.defined) {
             return this.hardDependencies.matches(kernelProvides)
-                ? 0
-                : 3 ;
+                ? NotebookRendererMatch.WithHardKernelDependency
+                : NotebookRendererMatch.Never;
         }
         return this.optionalDependencies.matches(kernelProvides)
-            ? 1
-            : 2 ;
+            ? NotebookRendererMatch.WithOptionalKernelDependency
+            : NotebookRendererMatch.Pure;
     }
     matchesMimeTypeOnly(mimeType) {
         if (this.entrypoint.extends) {

package/vscode/src/vs/workbench/contrib/notebook/common/notebookProvider.d.ts

@@ -0,0 +1,38 @@
+import * as glob from "vscode/vscode/vs/base/common/glob";
+import { URI } from "vscode/vscode/vs/base/common/uri";
+import { INotebookExclusiveDocumentFilter, TransientOptions } from "vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon";
+import { RegisteredEditorPriority } from "vscode/vscode/vs/workbench/services/editor/common/editorResolverService";
+import { ExtensionIdentifier } from "vscode/vscode/vs/platform/extensions/common/extensions";
+type NotebookSelector = string | glob.IRelativePattern | INotebookExclusiveDocumentFilter;
+export interface NotebookEditorDescriptor {
+    readonly extension?: ExtensionIdentifier;
+    readonly id: string;
+    readonly displayName: string;
+    readonly selectors: readonly {
+        filenamePattern?: string;
+        excludeFileNamePattern?: string;
+    }[];
+    readonly priority: RegisteredEditorPriority;
+    readonly providerDisplayName: string;
+}
+export declare class NotebookProviderInfo {
+    readonly extension?: ExtensionIdentifier;
+    readonly id: string;
+    readonly displayName: string;
+    readonly priority: RegisteredEditorPriority;
+    readonly providerDisplayName: string;
+    private _selectors;
+    get selectors(): NotebookSelector[];
+    private _options;
+    get options(): TransientOptions;
+    constructor(descriptor: NotebookEditorDescriptor);
+    update(args: {
+        selectors?: NotebookSelector[];
+        options?: TransientOptions;
+    }): void;
+    matches(resource: URI): boolean;
+    static selectorMatches(selector: NotebookSelector, resource: URI): boolean;
+    static possibleFileEnding(selectors: NotebookSelector[]): string | undefined;
+    private static _possibleFileEnding;
+}
+export {};

package/vscode/src/vs/workbench/contrib/notebook/common/notebookProvider.js

@@ -1,3 +1,4 @@
+
 import { match, isRelativePattern } from 'vscode/vscode/vs/base/common/glob';
 import { basename } from 'vscode/vscode/vs/base/common/path';
 import { isDocumentExcludePattern } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';

package/vscode/src/vs/workbench/contrib/notebook/common/services/notebookSimpleWorker.d.ts

@@ -0,0 +1,50 @@
+import { IDiffResult } from "vscode/vscode/vs/base/common/diff/diff";
+import { IDisposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { URI } from "vscode/vscode/vs/base/common/uri";
+import { IRequestHandler, IWorkerServer } from "vscode/vscode/vs/base/common/worker/simpleWorker";
+import { CellKind, IMainCellDto, INotebookDiffResult, IOutputDto, NotebookCellInternalMetadata, NotebookCellMetadata, NotebookCellsChangedEventDto, NotebookCellTextModelSplice, NotebookDocumentMetadata, TransientDocumentMetadata } from "vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon";
+import { DefaultEndOfLine } from "vscode/vscode/vs/editor/common/model";
+import { IModelChangedEvent } from "vscode/vscode/vs/editor/common/model/mirrorTextModel";
+declare class MirrorCell {
+    readonly handle: number;
+    private readonly _eol;
+    language: string;
+    cellKind: CellKind;
+    outputs: IOutputDto[];
+    metadata?: NotebookCellMetadata | undefined;
+    internalMetadata?: NotebookCellInternalMetadata | undefined;
+    private readonly textModel;
+    private _hash?;
+    get eol(): DefaultEndOfLine;
+    constructor(handle: number, uri: URI, source: string[], _eol: string, versionId: number, language: string, cellKind: CellKind, outputs: IOutputDto[], metadata?: NotebookCellMetadata | undefined, internalMetadata?: NotebookCellInternalMetadata | undefined);
+    onEvents(e: IModelChangedEvent): void;
+    getValue(): string;
+    getComparisonValue(): Promise<number>;
+    private _getHash;
+}
+declare class MirrorNotebookDocument {
+    readonly uri: URI;
+    cells: MirrorCell[];
+    metadata: NotebookDocumentMetadata;
+    transientDocumentMetadata: TransientDocumentMetadata;
+    constructor(uri: URI, cells: MirrorCell[], metadata: NotebookDocumentMetadata, transientDocumentMetadata: TransientDocumentMetadata);
+    acceptModelChanged(event: NotebookCellsChangedEventDto): void;
+    private _assertIndex;
+    _spliceNotebookCells(splices: NotebookCellTextModelSplice<IMainCellDto>[]): void;
+}
+export declare class NotebookEditorSimpleWorker implements IRequestHandler, IDisposable {
+    _requestHandlerBrand: any;
+    private _models;
+    constructor();
+    dispose(): void;
+    $acceptNewModel(uri: string, metadata: NotebookDocumentMetadata, transientDocumentMetadata: TransientDocumentMetadata, cells: IMainCellDto[]): void;
+    $acceptModelChanged(strURL: string, event: NotebookCellsChangedEventDto): void;
+    $acceptCellModelChanged(strURL: string, handle: number, event: IModelChangedEvent): void;
+    $acceptRemovedModel(strURL: string): void;
+    $computeDiff(originalUrl: string, modifiedUrl: string): Promise<INotebookDiffResult>;
+    $computeDiffWithCellIds(original: MirrorNotebookDocument, modified: MirrorNotebookDocument): Promise<IDiffResult | undefined>;
+    $canPromptRecommendation(modelUrl: string): boolean;
+    protected _getModel(uri: string): MirrorNotebookDocument;
+}
+export declare function create(workerServer: IWorkerServer): IRequestHandler;
+export {};

package/vscode/src/vs/workbench/contrib/notebook/common/services/notebookSimpleWorker.js

@@ -1,3 +1,4 @@
+
 import { LcsDiff } from 'vscode/vscode/vs/base/common/diff/diff';
 import { numberHash, doHash } from 'vscode/vscode/vs/base/common/hash';
 import { URI } from 'vscode/vscode/vs/base/common/uri';
@@ -6,11 +7,12 @@ import { NotebookCellsChangeType, CellKind } from 'vscode/vscode/vs/workbench/co
 import { Range } from 'vscode/vscode/vs/editor/common/core/range';
 import { SearchParams } from 'vscode/vscode/vs/editor/common/model/textModelSearch';
 import { MirrorModel } from 'vscode/vscode/vs/editor/common/services/textModelSync/textModelSync.impl';
+import { DefaultEndOfLine } from 'vscode/vscode/vs/editor/common/model';
 import { filter } from 'vscode/vscode/vs/base/common/objects';
 
 class MirrorCell {
     get eol() {
-        return this._eol === '\r\n' ? 2  : 1 ;
+        return this._eol === '\r\n' ? DefaultEndOfLine.CRLF : DefaultEndOfLine.LF;
     }
     constructor(handle, uri, source, _eol, versionId, language, cellKind, outputs, metadata, internalMetadata) {
         this.handle = handle;
@@ -114,6 +116,15 @@ class CellSequence {
         })));
         return ( new CellSequence(hashValue));
     }
+    static async createWithCellId(textModel) {
+        const hashValue = ( new Map());
+        await Promise.all(( textModel.cells.map(async (c, i) => {
+            const value = await c.getComparisonValue();
+            const id = (c.metadata?.id || '');
+            hashValue.set(id, value);
+        })));
+        return hashValue;
+    }
     constructor(hashValue) {
         this.hashValue = hashValue;
     }
@@ -160,6 +171,69 @@ class NotebookEditorSimpleWorker {
             cellsDiff: diffResult,
         };
     }
+    async $computeDiffWithCellIds(original, modified) {
+        const originalCellIds = ( original.cells.map((cell, index) => ({ index, id: (cell.metadata?.id || '') })));
+        const modifiedCellIds = ( modified.cells.map((cell, index) => ({ index, id: (cell.metadata?.id || '') })));
+        if (( originalCellIds.some(c => !c.id)) || ( modifiedCellIds.some(c => !c.id))) {
+            return;
+        }
+        const diffResult = { changes: [], quitEarly: false, };
+        const computeCellHashesById = async (notebook) => {
+            const hashValue = ( new Map());
+            await Promise.all(( notebook.cells.map(async (c, i) => {
+                const value = await c.getComparisonValue();
+                const id = (c.metadata?.id || '');
+                hashValue.set(id, value);
+            })));
+            return hashValue;
+        };
+        const [originalSeq, modifiedSeq] = await Promise.all([computeCellHashesById(original), computeCellHashesById(modified)]);
+        while (modifiedCellIds.length) {
+            const modifiedCell = modifiedCellIds.shift();
+            const originalCell = originalCellIds.find(c => c.id === modifiedCell.id);
+            if (originalCell) {
+                const index = originalCellIds.indexOf(originalCell);
+                const deletedFromOriginal = originalCellIds.splice(0, index + 1);
+                if (deletedFromOriginal.length === 1) {
+                    if (originalSeq.get(originalCell.id) === modifiedSeq.get(originalCell.id)) ;
+                    else {
+                        diffResult.changes.push({
+                            originalStart: originalCell.index,
+                            originalLength: 1,
+                            modifiedStart: modifiedCell.index,
+                            modifiedLength: 1
+                        });
+                    }
+                }
+                else {
+                    diffResult.changes.push({
+                        originalStart: deletedFromOriginal[0].index,
+                        originalLength: deletedFromOriginal.length - 1,
+                        modifiedStart: modifiedCell.index,
+                        modifiedLength: 0
+                    });
+                }
+                continue;
+            }
+            else {
+                diffResult.changes.push({
+                    originalStart: originalCellIds.length ? originalCellIds[0].index : original.cells.length,
+                    originalLength: 0,
+                    modifiedStart: modifiedCell.index,
+                    modifiedLength: 1
+                });
+            }
+        }
+        if (originalCellIds.length) {
+            diffResult.changes.push({
+                originalStart: originalCellIds[0].index,
+                originalLength: originalCellIds.length,
+                modifiedStart: modifiedCellIds.length,
+                modifiedLength: 0
+            });
+        }
+        return diffResult;
+    }
     $canPromptRecommendation(modelUrl) {
         const model = this._getModel(modelUrl);
         const cells = model.cells;

package/vscode/src/vs/workbench/contrib/notebook/common/services/notebookSimpleWorkerMain.d.ts

@@ -0,0 +1 @@
+export {};

package/vscode/src/vs/workbench/contrib/notebook/common/services/notebookSimpleWorkerMain.js

@@ -1,4 +1,5 @@
-import { bootstrapSimpleWorker } from 'vscode/vscode/vs/base/common/worker/simpleWorkerBootstrap';
+
+import { bootstrapSimpleWorker } from '@codingame/monaco-vscode-695440c8-a687-5594-b476-bbc7b36bafe9-common/vscode/vs/base/common/worker/simpleWorkerBootstrap';
 import { create } from './notebookSimpleWorker.js';
 
 bootstrapSimpleWorker(create);

package/vscode/src/vs/workbench/services/workingCopy/common/abstractFileWorkingCopyManager.d.ts

@@ -0,0 +1,31 @@
+import { Event } from "vscode/vscode/vs/base/common/event";
+import { Disposable, IDisposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { IFileService } from "vscode/vscode/vs/platform/files/common/files.service";
+import { URI } from "vscode/vscode/vs/base/common/uri";
+import { ILogService } from "vscode/vscode/vs/platform/log/common/log.service";
+import { IWorkingCopyBackupService } from "vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyBackup.service";
+import { IFileWorkingCopy, IFileWorkingCopyModel } from "@codingame/monaco-vscode-9d05a43d-c330-5ff1-937e-fde4a3852931-common/vscode/vs/workbench/services/workingCopy/common/fileWorkingCopy";
+export interface IBaseFileWorkingCopyManager<M extends IFileWorkingCopyModel, W extends IFileWorkingCopy<M>> extends IDisposable {
+    readonly onDidCreate: Event<W>;
+    readonly workingCopies: readonly W[];
+    get(resource: URI): W | undefined;
+    destroy(): Promise<void>;
+}
+export declare abstract class BaseFileWorkingCopyManager<M extends IFileWorkingCopyModel, W extends IFileWorkingCopy<M>> extends Disposable implements IBaseFileWorkingCopyManager<M, W> {
+    protected readonly fileService: IFileService;
+    protected readonly logService: ILogService;
+    protected readonly workingCopyBackupService: IWorkingCopyBackupService;
+    private readonly _onDidCreate;
+    readonly onDidCreate: Event<W>;
+    private readonly mapResourceToWorkingCopy;
+    private readonly mapResourceToDisposeListener;
+    constructor(fileService: IFileService, logService: ILogService, workingCopyBackupService: IWorkingCopyBackupService);
+    protected has(resource: URI): boolean;
+    protected add(resource: URI, workingCopy: W): void;
+    protected remove(resource: URI): boolean;
+    get workingCopies(): W[];
+    get(resource: URI): W | undefined;
+    dispose(): void;
+    destroy(): Promise<void>;
+    private saveWithFallback;
+}

package/vscode/src/vs/workbench/services/workingCopy/common/abstractFileWorkingCopyManager.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, dispose } from 'vscode/vscode/vs/base/common/lifecycle';
 import { ResourceMap } from 'vscode/vscode/vs/base/common/map';

package/vscode/src/vs/workbench/services/workingCopy/common/fileWorkingCopyManager.d.ts

@@ -0,0 +1,78 @@
+import { Event } from "vscode/vscode/vs/base/common/event";
+import { Disposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { URI } from "vscode/vscode/vs/base/common/uri";
+import { IFileDialogService } from "vscode/vscode/vs/platform/dialogs/common/dialogs.service";
+import { IDialogService } from "vscode/vscode/vs/platform/dialogs/common/dialogs.service";
+import { IFileService } from "vscode/vscode/vs/platform/files/common/files.service";
+import { ISaveOptions } from "vscode/vscode/vs/workbench/common/editor";
+import { IWorkbenchEnvironmentService } from "vscode/vscode/vs/workbench/services/environment/common/environmentService.service";
+import { IPathService } from "vscode/vscode/vs/workbench/services/path/common/pathService.service";
+import { IUriIdentityService } from "vscode/vscode/vs/platform/uriIdentity/common/uriIdentity.service";
+import { IStoredFileWorkingCopy, IStoredFileWorkingCopyModel, IStoredFileWorkingCopyModelFactory, IStoredFileWorkingCopyResolveOptions } from "@codingame/monaco-vscode-99f24462-c56d-5407-83fb-2ea9dd33cc8c-common/vscode/vs/workbench/services/workingCopy/common/storedFileWorkingCopy";
+import { IStoredFileWorkingCopyManager, IStoredFileWorkingCopyManagerResolveOptions } from "./storedFileWorkingCopyManager.js";
+import { IUntitledFileWorkingCopy, IUntitledFileWorkingCopyModel, IUntitledFileWorkingCopyModelFactory } from "./untitledFileWorkingCopy.js";
+import { INewOrExistingUntitledFileWorkingCopyOptions, INewUntitledFileWorkingCopyOptions, INewUntitledFileWorkingCopyWithAssociatedResourceOptions, IUntitledFileWorkingCopyManager } from "./untitledFileWorkingCopyManager.js";
+import { IWorkingCopyFileService } from "vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyFileService.service";
+import { IBaseFileWorkingCopyManager } from "./abstractFileWorkingCopyManager.js";
+import { IFileWorkingCopy } from "@codingame/monaco-vscode-9d05a43d-c330-5ff1-937e-fde4a3852931-common/vscode/vs/workbench/services/workingCopy/common/fileWorkingCopy";
+import { ILabelService } from "vscode/vscode/vs/platform/label/common/label.service";
+import { ILogService } from "vscode/vscode/vs/platform/log/common/log.service";
+import { INotificationService } from "vscode/vscode/vs/platform/notification/common/notification.service";
+import { IEditorService } from "vscode/vscode/vs/workbench/services/editor/common/editorService.service";
+import { IElevatedFileService } from "vscode/vscode/vs/workbench/services/files/common/elevatedFileService.service";
+import { IFilesConfigurationService } from "vscode/vscode/vs/workbench/services/filesConfiguration/common/filesConfigurationService.service";
+import { ILifecycleService } from "vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle.service";
+import { IWorkingCopyBackupService } from "vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyBackup.service";
+import { IWorkingCopyEditorService } from "vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyEditorService.service";
+import { IWorkingCopyService } from "vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyService.service";
+import { IDecorationsService } from "vscode/vscode/vs/workbench/services/decorations/common/decorations.service";
+import { IProgressService } from "vscode/vscode/vs/platform/progress/common/progress.service";
+export interface IFileWorkingCopyManager<S extends IStoredFileWorkingCopyModel, U extends IUntitledFileWorkingCopyModel> extends IBaseFileWorkingCopyManager<S | U, IFileWorkingCopy<S | U>> {
+    readonly stored: IStoredFileWorkingCopyManager<S>;
+    readonly untitled: IUntitledFileWorkingCopyManager<U>;
+    resolve(resource: URI, options?: IStoredFileWorkingCopyManagerResolveOptions): Promise<IStoredFileWorkingCopy<S>>;
+    resolve(options?: INewUntitledFileWorkingCopyOptions): Promise<IUntitledFileWorkingCopy<U>>;
+    resolve(options?: INewUntitledFileWorkingCopyWithAssociatedResourceOptions): Promise<IUntitledFileWorkingCopy<U>>;
+    resolve(options?: INewOrExistingUntitledFileWorkingCopyOptions): Promise<IUntitledFileWorkingCopy<U>>;
+    saveAs(source: URI, target: URI, options?: ISaveOptions): Promise<IStoredFileWorkingCopy<S> | undefined>;
+    saveAs(source: URI, target: undefined, options?: IFileWorkingCopySaveAsOptions): Promise<IStoredFileWorkingCopy<S> | undefined>;
+}
+export interface IFileWorkingCopySaveAsOptions extends ISaveOptions {
+    suggestedTarget?: URI;
+}
+export declare class FileWorkingCopyManager<S extends IStoredFileWorkingCopyModel, U extends IUntitledFileWorkingCopyModel> extends Disposable implements IFileWorkingCopyManager<S, U> {
+    private readonly workingCopyTypeId;
+    private readonly storedWorkingCopyModelFactory;
+    private readonly untitledWorkingCopyModelFactory;
+    private readonly fileService;
+    private readonly logService;
+    private readonly workingCopyFileService;
+    private readonly uriIdentityService;
+    private readonly fileDialogService;
+    private readonly filesConfigurationService;
+    private readonly pathService;
+    private readonly environmentService;
+    private readonly dialogService;
+    private readonly decorationsService;
+    readonly onDidCreate: Event<IFileWorkingCopy<S | U>>;
+    private static readonly FILE_WORKING_COPY_SAVE_CREATE_SOURCE;
+    private static readonly FILE_WORKING_COPY_SAVE_REPLACE_SOURCE;
+    readonly stored: IStoredFileWorkingCopyManager<S>;
+    readonly untitled: IUntitledFileWorkingCopyManager<U>;
+    constructor(workingCopyTypeId: string, storedWorkingCopyModelFactory: IStoredFileWorkingCopyModelFactory<S>, untitledWorkingCopyModelFactory: IUntitledFileWorkingCopyModelFactory<U>, fileService: IFileService, lifecycleService: ILifecycleService, labelService: ILabelService, logService: ILogService, workingCopyFileService: IWorkingCopyFileService, workingCopyBackupService: IWorkingCopyBackupService, uriIdentityService: IUriIdentityService, fileDialogService: IFileDialogService, filesConfigurationService: IFilesConfigurationService, workingCopyService: IWorkingCopyService, notificationService: INotificationService, workingCopyEditorService: IWorkingCopyEditorService, editorService: IEditorService, elevatedFileService: IElevatedFileService, pathService: IPathService, environmentService: IWorkbenchEnvironmentService, dialogService: IDialogService, decorationsService: IDecorationsService, progressService: IProgressService);
+    private provideDecorations;
+    get workingCopies(): (IUntitledFileWorkingCopy<U> | IStoredFileWorkingCopy<S>)[];
+    get(resource: URI): IUntitledFileWorkingCopy<U> | IStoredFileWorkingCopy<S> | undefined;
+    resolve(options?: INewUntitledFileWorkingCopyOptions): Promise<IUntitledFileWorkingCopy<U>>;
+    resolve(options?: INewUntitledFileWorkingCopyWithAssociatedResourceOptions): Promise<IUntitledFileWorkingCopy<U>>;
+    resolve(options?: INewOrExistingUntitledFileWorkingCopyOptions): Promise<IUntitledFileWorkingCopy<U>>;
+    resolve(resource: URI, options?: IStoredFileWorkingCopyResolveOptions): Promise<IStoredFileWorkingCopy<S>>;
+    saveAs(source: URI, target?: URI, options?: IFileWorkingCopySaveAsOptions): Promise<IStoredFileWorkingCopy<S> | undefined>;
+    private doSave;
+    private doSaveAs;
+    private doResolveSaveTarget;
+    private confirmOverwrite;
+    private confirmMakeWriteable;
+    private suggestSavePath;
+    destroy(): Promise<void>;
+}