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

package/package.json

@@ -1,6 +1,8 @@
 {
   "name": "@codingame/monaco-vscode-views-service-override",
-  "version": "11.1.2",
+  "version": "12.0.0",
+  "private": false,
+  "description": "VSCode public API plugged on the monaco editor - views service-override",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -12,8 +14,39 @@
     "url": "git+ssh://git@github.com/CodinGame/monaco-vscode-api.git"
   },
   "type": "module",
-  "private": false,
-  "description": "VSCode public API plugged on the monaco editor - views service-override",
+  "dependencies": {
+    "@codingame/monaco-vscode-0139c6af-2375-559c-af57-b738f2fd6d8e-common": "12.0.0",
+    "@codingame/monaco-vscode-0cc5da60-f921-59b9-bd8c-a018e93c0a6f-common": "12.0.0",
+    "@codingame/monaco-vscode-0ccdeafc-77d6-5aa8-b465-b7d03b8fb10f-common": "12.0.0",
+    "@codingame/monaco-vscode-6980eeab-47bb-5a48-8e15-32caf0785565-common": "12.0.0",
+    "@codingame/monaco-vscode-9e888134-1a6f-58d9-b0e6-0fc047448366-common": "12.0.0",
+    "@codingame/monaco-vscode-cc2b8dc7-d125-518e-bf7e-99a1db5babd1-common": "12.0.0",
+    "@codingame/monaco-vscode-d6e33d82-c101-549d-a885-0807ab3e0cfb-common": "12.0.0",
+    "@codingame/monaco-vscode-d8236b3b-b91a-522d-89f4-94d70a546f6a-common": "12.0.0",
+    "@codingame/monaco-vscode-e571cbbb-526b-5d8b-92c5-a0437d2dabb3-common": "12.0.0",
+    "@codingame/monaco-vscode-e97d19fd-ad95-5915-8104-6f1a86c7b652-common": "12.0.0",
+    "@codingame/monaco-vscode-keybindings-service-override": "12.0.0",
+    "@codingame/monaco-vscode-layout-service-override": "12.0.0",
+    "@codingame/monaco-vscode-quickaccess-service-override": "12.0.0",
+    "@codingame/monaco-vscode-view-common-service-override": "12.0.0",
+    "vscode": "npm:@codingame/monaco-vscode-api@12.0.0"
+  },
+  "peerDependencies": {
+    "@codingame/monaco-vscode-b8988f79-16c1-5bff-b0e7-699bab3431da-common": "12.0.0",
+    "@codingame/monaco-vscode-c3c61c00-c254-5856-9dc9-d7929c1f9062-common": "12.0.0",
+    "@codingame/monaco-vscode-workbench-service-override": "12.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@codingame/monaco-vscode-b8988f79-16c1-5bff-b0e7-699bab3431da-common": {
+      "optional": true
+    },
+    "@codingame/monaco-vscode-c3c61c00-c254-5856-9dc9-d7929c1f9062-common": {
+      "optional": true
+    },
+    "@codingame/monaco-vscode-workbench-service-override": {
+      "optional": true
+    }
+  },
   "main": "index.js",
   "module": "index.js",
   "types": "index.d.ts",
@@ -22,14 +55,12 @@
       "default": "./index.js"
     },
     "./vscode/*": {
-      "default": "./vscode/src/*.js"
+      "default": "./vscode/src/*.js",
+      "types": "./vscode/src/*.d.ts"
+    },
+    "./*": {
+      "default": "./*.js",
+      "types": "./*.d.ts"
     }
-  },
-  "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@11.1.2",
-    "@codingame/monaco-vscode-view-common-views-workbench-common": "11.1.2",
-    "@codingame/monaco-vscode-quickaccess-service-override": "11.1.2",
-    "@codingame/monaco-vscode-keybindings-service-override": "11.1.2",
-    "@codingame/monaco-vscode-view-common-service-override": "11.1.2"
   }
 }

package/service-override/tools/editor.d.ts

@@ -0,0 +1,286 @@
+import { type PreferredGroup } from "vscode/vscode/vs/workbench/services/editor/common/editorService";
+import { IEditorService } from "vscode/vscode/vs/workbench/services/editor/common/editorService.service";
+import { type EditorInputWithOptions, type IActiveEditorChangeEvent, type IEditorCloseEvent, type IEditorControl, type IEditorPane, type IEditorWillOpenEvent, type IResourceDiffEditorInput, type ITextDiffEditorPane, type IUntitledTextResourceEditorInput, type IUntypedEditorInput, type IVisibleEditorPane } from "vscode/vscode/vs/workbench/common/editor";
+import { EditorInput } from "vscode/vscode/vs/workbench/common/editor/editorInput";
+import type { IEditorOptions, IResourceEditorInput, ITextResourceEditorInput } from "vscode/vscode/vs/platform/editor/common/editor";
+import type { ICodeEditor, IDiffEditor } from "vscode/vscode/vs/editor/browser/editorBrowser";
+import { type IEditorGroupView } from "vscode/vscode/vs/workbench/browser/parts/editor/editor";
+import { type IResolvedTextEditorModel, ITextModelService } from "vscode/vscode/vs/editor/common/services/resolverService";
+import { type IStandaloneCodeEditor } from "vscode/vscode/vs/editor/standalone/browser/standaloneCodeEditor";
+import { Disposable, type IDisposable, type IReference } from "vscode/vscode/vs/base/common/lifecycle";
+import { EditorService } from "@codingame/monaco-vscode-b8988f79-16c1-5bff-b0e7-699bab3431da-common/vscode/vs/workbench/services/editor/browser/editorService";
+import { type IAuxiliaryEditorPart, type IEditorDropTargetDelegate, type IEditorPart, type IActiveEditorActions, type IEditorGroup, type IEditorWorkingSet, type IEditorGroupContextKeyProvider } from "vscode/vscode/vs/workbench/services/editor/common/editorGroupsService";
+import { IEditorGroupsService } from "vscode/vscode/vs/workbench/services/editor/common/editorGroupsService.service";
+import { IInstantiationService } from "vscode/vscode/vs/platform/instantiation/common/instantiation";
+import { IConfigurationService } from "vscode/vscode/vs/platform/configuration/common/configuration.service";
+import { IWorkspaceTrustRequestService } from "vscode/vscode/vs/platform/workspace/common/workspaceTrust.service";
+import { IEditorResolverService } from "vscode/vscode/vs/workbench/services/editor/common/editorResolverService.service";
+import { IUriIdentityService } from "vscode/vscode/vs/platform/uriIdentity/common/uriIdentity.service";
+import { IWorkspaceContextService } from "vscode/vscode/vs/platform/workspace/common/workspace.service";
+import { IFileService } from "vscode/vscode/vs/platform/files/common/files.service";
+import { ITextEditorService } from "vscode/vscode/vs/workbench/services/textfile/common/textEditorService.service";
+import { IHostService } from "vscode/vscode/vs/workbench/services/host/browser/host.service";
+import { Emitter, Event } from "vscode/vscode/vs/base/common/event";
+import { TextResourceEditorInput } from "@codingame/monaco-vscode-0139c6af-2375-559c-af57-b738f2fd6d8e-common/vscode/vs/workbench/common/editor/textResourceEditorInput";
+import { IContextKeyService } from "vscode/vscode/vs/platform/contextkey/common/contextkey.service";
+import { URI } from "vscode/vscode/vs/base/common/uri";
+import type { IGroupModelChangeEvent } from "@codingame/monaco-vscode-c3c61c00-c254-5856-9dc9-d7929c1f9062-common/vscode/vs/workbench/common/editor/editorGroupModel";
+import type { EditorLayoutInfo } from "vscode/vscode/vs/editor/common/config/editorOptions";
+import type { IRectangle } from "vscode/vscode/vs/platform/window/common/window";
+import type { ContextKeyValue } from "vscode/vscode/vs/platform/contextkey/common/contextkey";
+import { unsupported } from "vscode/tools";
+export type OpenEditor = (modelRef: IReference<IResolvedTextEditorModel>, options: IEditorOptions | undefined, sideBySide?: boolean) => Promise<ICodeEditor | undefined>;
+declare class EmptyEditorGroup implements IEditorGroup, IEditorGroupView {
+    selectedEditors: never[];
+    isSelected: () => boolean;
+    setSelection: typeof unsupported;
+    isTransient: () => boolean;
+    windowId: number;
+    get groupsView(): never;
+    notifyLabelChanged(): void;
+    createEditorActions: typeof unsupported;
+    onDidFocus: Event<any>;
+    onDidOpenEditorFail: Event<any>;
+    whenRestored: Promise<void>;
+    get titleHeight(): never;
+    disposed: boolean;
+    setActive: typeof unsupported;
+    notifyIndexChanged: typeof unsupported;
+    relayout: typeof unsupported;
+    dispose: typeof unsupported;
+    toJSON: typeof unsupported;
+    preferredWidth?: number | undefined;
+    preferredHeight?: number | undefined;
+    get element(): never;
+    minimumWidth: number;
+    maximumWidth: number;
+    minimumHeight: number;
+    maximumHeight: number;
+    onDidChange: Event<any>;
+    layout: typeof unsupported;
+    onDidModelChange: Event<any>;
+    onWillDispose: Event<any>;
+    onDidActiveEditorChange: Event<any>;
+    onWillCloseEditor: Event<any>;
+    onDidCloseEditor: Event<any>;
+    onWillMoveEditor: Event<any>;
+    onWillOpenEditor: Event<any>;
+    id: number;
+    index: number;
+    label: string;
+    ariaLabel: string;
+    activeEditorPane: undefined;
+    activeEditor: null;
+    previewEditor: null;
+    count: number;
+    isEmpty: boolean;
+    isLocked: boolean;
+    stickyCount: number;
+    editors: never[];
+    get scopedContextKeyService(): IContextKeyService;
+    getEditors: () => never[];
+    findEditors: () => never[];
+    getEditorByIndex: () => undefined;
+    getIndexOfEditor: typeof unsupported;
+    openEditor: typeof unsupported;
+    openEditors: typeof unsupported;
+    isPinned: () => boolean;
+    isSticky: () => boolean;
+    isActive: () => boolean;
+    contains: () => boolean;
+    moveEditor: typeof unsupported;
+    moveEditors: typeof unsupported;
+    copyEditor: typeof unsupported;
+    copyEditors: typeof unsupported;
+    closeEditor: typeof unsupported;
+    closeEditors: typeof unsupported;
+    closeAllEditors: typeof unsupported;
+    replaceEditors: typeof unsupported;
+    pinEditor: () => void;
+    stickEditor: () => void;
+    unstickEditor: () => void;
+    lock: () => void;
+    focus(): void;
+    isFirst: typeof unsupported;
+    isLast: typeof unsupported;
+}
+export declare const fakeActiveGroup: EmptyEditorGroup;
+export declare function wrapOpenEditor(textModelService: ITextModelService, defaultBehavior: IEditorService["openEditor"], fallbackBahavior?: OpenEditor): IEditorService["openEditor"];
+export declare class MonacoEditorService extends EditorService {
+    private _isEditorPartVisible;
+    constructor(_openEditorFallback: OpenEditor | undefined, _isEditorPartVisible: () => boolean, _editorGroupService: IEditorGroupsService, instantiationService: IInstantiationService, fileService: IFileService, configurationService: IConfigurationService, contextService: IWorkspaceContextService, uriIdentityService: IUriIdentityService, editorResolverService: IEditorResolverService, workspaceTrustRequestService: IWorkspaceTrustRequestService, hostService: IHostService, textEditorService: ITextEditorService, textModelService: ITextModelService);
+    get activeTextEditorControl(): ICodeEditor | IDiffEditor | undefined;
+    openEditor(editor: EditorInput, options?: IEditorOptions, group?: PreferredGroup): Promise<IEditorPane | undefined>;
+    openEditor(editor: IUntypedEditorInput, group?: PreferredGroup): Promise<IEditorPane | undefined>;
+    openEditor(editor: IResourceEditorInput, group?: PreferredGroup): Promise<IEditorPane | undefined>;
+    openEditor(editor: ITextResourceEditorInput | IUntitledTextResourceEditorInput, group?: PreferredGroup): Promise<IEditorPane | undefined>;
+    openEditor(editor: IResourceDiffEditorInput, group?: PreferredGroup): Promise<ITextDiffEditorPane | undefined>;
+    openEditor(editor: EditorInput | IUntypedEditorInput, optionsOrPreferredGroup?: IEditorOptions | PreferredGroup, preferredGroup?: PreferredGroup): Promise<IEditorPane | undefined>;
+}
+declare class StandaloneEditorPane implements IVisibleEditorPane {
+    readonly editor: IStandaloneCodeEditor;
+    input: TextResourceEditorInput;
+    group: IEditorGroup;
+    constructor(editor: IStandaloneCodeEditor, input: TextResourceEditorInput, group: IEditorGroup);
+    onDidChangeControl: Event<any>;
+    options: undefined;
+    minimumWidth: number;
+    maximumWidth: number;
+    minimumHeight: number;
+    maximumHeight: number;
+    onDidChangeSizeConstraints: Event<any>;
+    scopedContextKeyService: undefined;
+    getControl(): IEditorControl | undefined;
+    getViewState(): object | undefined;
+    isVisible(): boolean;
+    onDidFocus: Event<void>;
+    onDidBlur: Event<void>;
+    hasFocus(): boolean;
+    getId(): string;
+    getTitle(): string | undefined;
+    focus(): void;
+}
+declare class StandaloneEditorGroup extends Disposable implements IEditorGroup, IEditorGroupView {
+    editor: IStandaloneCodeEditor;
+    scopedContextKeyService: IContextKeyService;
+    private static idCounter;
+    private pane;
+    active: boolean;
+    constructor(editor: IStandaloneCodeEditor, instantiationService: IInstantiationService, scopedContextKeyService: IContextKeyService);
+    selectedEditors: never[];
+    isSelected: () => boolean;
+    setSelection: typeof unsupported;
+    isTransient: () => boolean;
+    windowId: number;
+    get groupsView(): never;
+    notifyLabelChanged(): void;
+    createEditorActions(): IActiveEditorActions;
+    onDidFocus: Event<void>;
+    onDidOpenEditorFail: Event<any>;
+    whenRestored: Promise<void>;
+    get titleHeight(): never;
+    disposed: boolean;
+    setActive(isActive: boolean): void;
+    notifyIndexChanged: typeof unsupported;
+    relayout: typeof unsupported;
+    toJSON: typeof unsupported;
+    get element(): HTMLElement;
+    minimumWidth: number;
+    maximumWidth: number;
+    minimumHeight: number;
+    maximumHeight: number;
+    onDidChange: Event<EditorLayoutInfo>;
+    layout: () => void;
+    _onDidModelChange: Emitter<IGroupModelChangeEvent>;
+    onDidModelChange: Event<IGroupModelChangeEvent>;
+    onWillDispose: (listener: () => void) => IDisposable;
+    _onDidActiveEditorChange: Emitter<IActiveEditorChangeEvent>;
+    onDidActiveEditorChange: Event<IActiveEditorChangeEvent>;
+    onWillCloseEditor: Event<any>;
+    _onDidCloseEditor: Emitter<IEditorCloseEvent>;
+    onDidCloseEditor: Event<IEditorCloseEvent>;
+    onWillMoveEditor: Event<any>;
+    _onWillOpenEditor: Emitter<IEditorWillOpenEvent>;
+    onWillOpenEditor: Event<IEditorWillOpenEvent>;
+    readonly id: number;
+    index: number;
+    label: string;
+    ariaLabel: string;
+    get activeEditorPane(): StandaloneEditorPane | undefined;
+    get activeEditor(): TextResourceEditorInput | null;
+    previewEditor: null;
+    get count(): 1 | 0;
+    get isEmpty(): boolean;
+    isLocked: boolean;
+    stickyCount: number;
+    get editors(): TextResourceEditorInput[];
+    getEditors: () => TextResourceEditorInput[];
+    findEditors: (resource: URI) => TextResourceEditorInput[];
+    getEditorByIndex: (index: number) => TextResourceEditorInput | undefined;
+    getIndexOfEditor: (editorInput: EditorInput) => 0 | -1;
+    openEditor: (editor: EditorInput) => Promise<IEditorPane | undefined>;
+    openEditors: (editors: EditorInputWithOptions[]) => Promise<IEditorPane | undefined>;
+    isPinned: () => boolean;
+    isSticky: () => boolean;
+    isActive: () => boolean;
+    contains: (candidate: EditorInput | IUntypedEditorInput) => boolean;
+    moveEditor: typeof unsupported;
+    moveEditors: typeof unsupported;
+    copyEditor: typeof unsupported;
+    copyEditors: typeof unsupported;
+    closeEditor: typeof unsupported;
+    closeEditors: typeof unsupported;
+    closeAllEditors: typeof unsupported;
+    replaceEditors: typeof unsupported;
+    pinEditor: () => void;
+    stickEditor: () => void;
+    unstickEditor: () => void;
+    lock: () => void;
+    focus(): void;
+    isFirst: typeof unsupported;
+    isLast: typeof unsupported;
+}
+export declare class MonacoDelegateEditorGroupsService<D extends IEditorGroupsService> extends Disposable implements IEditorGroupsService {
+    protected delegate: D;
+    private instantiationService;
+    readonly _serviceBrand: undefined;
+    additionalGroups: StandaloneEditorGroup[];
+    activeGroupOverride: StandaloneEditorGroup | undefined;
+    constructor(delegate: D, emptyDelegate: boolean, instantiationService: IInstantiationService);
+    getScopedInstantiationService(): IInstantiationService;
+    registerContextKeyProvider<T extends ContextKeyValue>(provider: IEditorGroupContextKeyProvider<T>): IDisposable;
+    saveWorkingSet(name: string): IEditorWorkingSet;
+    getWorkingSets(): IEditorWorkingSet[];
+    applyWorkingSet(workingSet: IEditorWorkingSet | "empty"): Promise<boolean>;
+    deleteWorkingSet(workingSet: IEditorWorkingSet): void;
+    get isReady(): IEditorGroupsService["isReady"];
+    get whenReady(): IEditorGroupsService["whenReady"];
+    get whenRestored(): IEditorGroupsService["whenRestored"];
+    get hasRestorableState(): IEditorGroupsService["hasRestorableState"];
+    onDidCreateAuxiliaryEditorPart: Event<IAuxiliaryEditorPart>;
+    get parts(): IEditorGroupsService["parts"];
+    createAuxiliaryEditorPart(options?: {
+        bounds?: Partial<IRectangle> | undefined;
+    } | undefined): Promise<IAuxiliaryEditorPart>;
+    get mainPart(): IEditorGroupsService["mainPart"];
+    onDidChangeGroupMaximized: Event<boolean>;
+    getPart(group: number | IEditorGroup): IEditorPart;
+    getPart(container: unknown): IEditorPart | undefined;
+    toggleMaximizeGroup(group?: number | IEditorGroup | undefined): void;
+    toggleExpandGroup(group?: number | IEditorGroup | undefined): void;
+    createEditorDropTarget(container: unknown, delegate: IEditorDropTargetDelegate): IDisposable;
+    get groups(): IEditorGroup[];
+    get activeGroup(): IEditorGroup;
+    _onDidChangeActiveGroup: Emitter<IEditorGroup>;
+    onDidChangeActiveGroup: Event<IEditorGroup>;
+    _onDidAddGroup: Emitter<IEditorGroup>;
+    onDidAddGroup: Event<IEditorGroup>;
+    _onDidRemoveGroup: Emitter<IEditorGroup>;
+    onDidRemoveGroup: Event<IEditorGroup>;
+    onDidMoveGroup: Event<IEditorGroup>;
+    onDidActivateGroup: Event<IEditorGroup>;
+    onDidChangeGroupIndex: Event<IEditorGroup>;
+    onDidChangeGroupLocked: Event<IEditorGroup>;
+    get sideGroup(): IEditorGroupsService["sideGroup"];
+    get count(): IEditorGroupsService["count"];
+    get orientation(): IEditorGroupsService["orientation"];
+    get partOptions(): IEditorGroupsService["partOptions"];
+    getLayout: IEditorGroupsService["getLayout"];
+    getGroups: IEditorGroupsService["getGroups"];
+    getGroup: IEditorGroupsService["getGroup"];
+    activateGroup: IEditorGroupsService["activateGroup"];
+    getSize: IEditorGroupsService["getSize"];
+    setSize: IEditorGroupsService["setSize"];
+    arrangeGroups: IEditorGroupsService["arrangeGroups"];
+    applyLayout: IEditorGroupsService["applyLayout"];
+    setGroupOrientation: IEditorGroupsService["setGroupOrientation"];
+    findGroup: IEditorGroupsService["findGroup"];
+    addGroup: IEditorGroupsService["addGroup"];
+    removeGroup: IEditorGroupsService["removeGroup"];
+    moveGroup: IEditorGroupsService["moveGroup"];
+    mergeGroup: IEditorGroupsService["mergeGroup"];
+    mergeAllGroups: IEditorGroupsService["mergeAllGroups"];
+    copyGroup: IEditorGroupsService["copyGroup"];
+    onDidChangeEditorPartOptions: Event<import("vscode/vscode/vs/workbench/common/editor").IEditorPartOptionsChangeEvent>;
+}
+export {};

package/service-override/tools/views.d.ts

@@ -0,0 +1,105 @@
+import { type IViewContainerDescriptor, type IViewContainersRegistry, type IViewDescriptor, type IViewsRegistry, type ViewContainer, ViewContainerLocation } from "vscode/vscode/vs/workbench/common/views";
+import type { BrandedService, ServicesAccessor } from "vscode/vscode/vs/platform/instantiation/common/instantiation";
+import { type IDisposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { Dimension } from "vscode/vscode/vs/base/browser/dom";
+import { ViewPaneContainer } from "@codingame/monaco-vscode-9e888134-1a6f-58d9-b0e6-0fc047448366-common/vscode/vs/workbench/browser/parts/views/viewPaneContainer";
+import { URI } from "vscode/vscode/vs/base/common/uri";
+import { Codicon } from "vscode/vscode/vs/base/common/codicons";
+import { type EditorInputFactoryObject, type RegisteredEditorInfo, type RegisteredEditorOptions, RegisteredEditorPriority } from "vscode/vscode/vs/workbench/services/editor/common/editorResolverService";
+import { EditorInput, type IEditorCloseHandler } from "vscode/vscode/vs/workbench/common/editor/editorInput";
+import { EditorInputCapabilities, type IEditorOpenContext, type IEditorSerializer, Verbosity } from "vscode/vscode/vs/workbench/common/editor";
+import type { IEditorOptions, IResourceEditorInput } from "vscode/vscode/vs/platform/editor/common/editor";
+import { EditorPane } from "@codingame/monaco-vscode-9e888134-1a6f-58d9-b0e6-0fc047448366-common/vscode/vs/workbench/browser/parts/editor/editorPane";
+import { CancellationToken } from "vscode/vscode/vs/base/common/cancellation";
+import { DomScrollableElement } from "vscode/vscode/vs/base/browser/ui/scrollbar/scrollableElement";
+import { ConfirmResult } from "@codingame/monaco-vscode-d6e33d82-c101-549d-a885-0807ab3e0cfb-common/vscode/vs/platform/dialogs/common/dialogs";
+import { AbstractResourceEditorInput } from "@codingame/monaco-vscode-0139c6af-2375-559c-af57-b738f2fd6d8e-common/vscode/vs/workbench/common/editor/resourceEditorInput";
+import { AbstractTextResourceEditorInput } from "@codingame/monaco-vscode-0139c6af-2375-559c-af57-b738f2fd6d8e-common/vscode/vs/workbench/common/editor/textResourceEditorInput";
+import { Parts, Position } from "@codingame/monaco-vscode-e571cbbb-526b-5d8b-92c5-a0437d2dabb3-common/vscode/vs/workbench/services/layout/browser/layoutService";
+import { Event } from "vscode/vscode/vs/base/common/event";
+import { type IView, SplitView } from "vscode/vscode/vs/base/browser/ui/splitview/splitview";
+import { type IEditorGroup } from "vscode/services";
+type Label = string | {
+    short: string;
+    medium: string;
+    long: string;
+};
+declare abstract class InjectedEditorPane extends EditorPane {
+    constructor(id: string, group: IEditorGroup);
+}
+declare abstract class SimpleEditorPane extends InjectedEditorPane {
+    protected container: HTMLElement;
+    protected wrapper: HTMLElement;
+    protected scrollbar: DomScrollableElement | undefined;
+    private inputDisposable;
+    protected createEditor(parent: HTMLElement): void;
+    setInput(input: EditorInput, editorOptions: IEditorOptions | undefined, context: IEditorOpenContext, token: CancellationToken): Promise<void>;
+    layout(dimension: Dimension): void;
+    focus(): void;
+    clearInput(): void;
+    abstract initialize(): HTMLElement;
+    abstract renderInput?(input: EditorInput, options: IEditorOptions | undefined, context: IEditorOpenContext, token: CancellationToken): Promise<IDisposable>;
+}
+declare abstract class SimpleEditorInput extends EditorInput {
+    closeHandler?: IEditorCloseHandler | undefined;
+    private dirty;
+    private _capabilities;
+    private name;
+    private title;
+    private description;
+    resource: URI | undefined;
+    constructor(resource?: URI, closeHandler?: IEditorCloseHandler | undefined);
+    get capabilities(): EditorInputCapabilities;
+    addCapability(capability: EditorInputCapabilities): void;
+    removeCapability(capability: EditorInputCapabilities): void;
+    get editorId(): string | undefined;
+    setName(name: string): void;
+    setTitle(title: Label): void;
+    setDescription(description: string): void;
+    private getLabelValue;
+    getName(): string;
+    getTitle(verbosity?: Verbosity): string;
+    getDescription(verbosity?: Verbosity): string;
+    isDirty(): boolean;
+    setDirty(dirty: boolean): void;
+    toUntyped(): IResourceEditorInput | undefined;
+}
+declare function registerEditorPane<Services extends BrandedService[]>(typeId: string, name: string, ctor: new (group: IEditorGroup, ...services: Services) => EditorPane, inputCtors: (new (...args: any[]) => EditorInput)[]): IDisposable;
+declare function registerEditor(globPattern: string, editorInfo: RegisteredEditorInfo, editorOptions: RegisteredEditorOptions, factory: EditorInputFactoryObject): IDisposable;
+declare function registerEditorSerializer<Services extends BrandedService[]>(editorTypeId: string, ctor: {
+    new (...Services: Services): IEditorSerializer;
+}): IDisposable;
+interface CustomViewOption {
+    readonly id: string;
+    name: string;
+    order?: number;
+    renderBody(container: HTMLElement, scrollbar: DomScrollableElement): IDisposable;
+    location: ViewContainerLocation;
+    icon?: string;
+    canMoveView?: boolean;
+    default?: boolean;
+    actions?: {
+        id: string;
+        title: string;
+        tooltip?: string;
+        order?: number;
+        run?(accessor: ServicesAccessor): Promise<void>;
+        icon?: keyof typeof Codicon;
+        render?(container: HTMLElement): void;
+    }[];
+    viewContainer?: ViewContainer;
+    canToggleVisibility?: boolean;
+    hideByDefault?: boolean;
+    collapsed?: boolean;
+}
+declare const viewContainerRegistry: IViewContainersRegistry;
+declare const viewRegistry: IViewsRegistry;
+declare function registerCustomView(options: CustomViewOption): IDisposable;
+export declare function isPartVisibile(part: Parts): boolean;
+export declare function setPartVisibility(part: Exclude<Parts, Parts.STATUSBAR_PART | Parts.TITLEBAR_PART>, visible: boolean): void;
+export declare const onDidChangePanelPosition: Event<string>;
+export declare function getPanelPosition(): Position;
+export declare const onDidChangeSideBarPosition: Event<string>;
+export declare function getSideBarPosition(): Position;
+export { ViewContainerLocation, registerCustomView, ViewPaneContainer, ConfirmResult, registerEditorPane, RegisteredEditorPriority, InjectedEditorPane as EditorPane, SimpleEditorPane, SimpleEditorInput, AbstractResourceEditorInput, AbstractTextResourceEditorInput, EditorInput, registerEditor, registerEditorSerializer, EditorInputCapabilities, Parts, SplitView, viewRegistry, viewContainerRegistry, DomScrollableElement };
+export type { IEditorSerializer, CustomViewOption, IEditorCloseHandler, RegisteredEditorInfo, RegisteredEditorOptions, EditorInputFactoryObject, IView, IViewContainerDescriptor, ViewContainer, IViewDescriptor };