@codingame/monaco-vscode-api 4.5.0 → 4.5.2

package/vscode/src/vs/workbench/contrib/terminal/browser/terminal.service.d.ts

@@ -0,0 +1,149 @@
+import { ServiceIdentifier } from '../../../../platform/instantiation/common/instantiation.js';
+import { Event, IDynamicListEventMultiplexer } from '../../../../base/common/event.js';
+import { URI } from '../../../../base/common/uri.js';
+import { TerminalCapability, ITerminalCapabilityImplMap } from '../../../../platform/terminal/common/capabilities/capabilities.js';
+import { TerminalLocation, ITerminalBackend, ITerminalLaunchError, IShellLaunchConfig, ITerminalProfile } from '../../../../platform/terminal/common/terminal.js';
+import { IEditableData } from '../../../common/views.js';
+import { IStartExtensionTerminalRequest, ITerminalProcessExtHostProxy, IRemoteTerminalAttachTarget } from '../common/terminal.js';
+import { GroupIdentifier } from '../../../common/editor.js';
+import { SIDE_GROUP_TYPE, ACTIVE_GROUP_TYPE, AUX_WINDOW_GROUP_TYPE } from '../../../services/editor/common/editorService.js';
+import { ITerminalInstanceHost, ITerminalInstance, IDetachedTerminalInstance, ITerminalConfigHelper, TerminalConnectionState, ITerminalGroup, ICreateTerminalOptions, IDetachedXTermOptions, ITerminalLocationOptions, ITerminalServiceNativeDelegate } from './terminal.js';
+
+declare const ITerminalService: ServiceIdentifier<ITerminalService>;
+interface ITerminalService extends ITerminalInstanceHost {
+    readonly _serviceBrand: undefined;
+    /** Gets all terminal instances, including editor and terminal view (group) instances. */
+    readonly instances: readonly ITerminalInstance[];
+    /** Gets detached terminal instances created via {@link createDetachedXterm}. */
+    readonly detachedInstances: Iterable<IDetachedTerminalInstance>;
+    readonly configHelper: ITerminalConfigHelper;
+    readonly defaultLocation: TerminalLocation;
+    readonly isProcessSupportRegistered: boolean;
+    readonly connectionState: TerminalConnectionState;
+    readonly whenConnected: Promise<void>;
+    /** The number of restored terminal groups on startup. */
+    readonly restoredGroupCount: number;
+    readonly onDidCreateInstance: Event<ITerminalInstance>;
+    readonly onDidChangeInstanceDimensions: Event<ITerminalInstance>;
+    readonly onDidRequestStartExtensionTerminal: Event<IStartExtensionTerminalRequest>;
+    readonly onDidRegisterProcessSupport: Event<void>;
+    readonly onDidChangeConnectionState: Event<void>;
+    readonly onDidChangeActiveGroup: Event<ITerminalGroup | undefined>;
+    readonly onAnyInstanceData: Event<{
+        instance: ITerminalInstance;
+        data: string;
+    }>;
+    readonly onAnyInstanceDataInput: Event<ITerminalInstance>;
+    readonly onAnyInstanceIconChange: Event<{
+        instance: ITerminalInstance;
+        userInitiated: boolean;
+    }>;
+    readonly onAnyInstanceMaximumDimensionsChange: Event<ITerminalInstance>;
+    readonly onAnyInstancePrimaryStatusChange: Event<ITerminalInstance>;
+    readonly onAnyInstanceProcessIdReady: Event<ITerminalInstance>;
+    readonly onAnyInstanceSelectionChange: Event<ITerminalInstance>;
+    readonly onAnyInstanceTitleChange: Event<ITerminalInstance>;
+    /**
+    * Creates a terminal.
+    * @param options The options to create the terminal with, when not specified the default
+    * profile will be used at the default target.
+    */
+    createTerminal(options?: ICreateTerminalOptions): Promise<ITerminalInstance>;
+    /**
+    * Creates a detached xterm instance which is not attached to the DOM or
+    * tracked as a terminal instance.
+    * @params options The options to create the terminal with
+    */
+    createDetachedTerminal(options: IDetachedXTermOptions): Promise<IDetachedTerminalInstance>;
+    /**
+    * Creates a raw terminal instance, this should not be used outside of the terminal part.
+    */
+    getInstanceFromId(terminalId: number): ITerminalInstance | undefined;
+    getInstanceFromIndex(terminalIndex: number): ITerminalInstance;
+    /**
+    * An owner of terminals might be created after reconnection has occurred,
+    * so store them to be requested/adopted later
+    */
+    getReconnectedTerminals(reconnectionOwner: string): ITerminalInstance[] | undefined;
+    getActiveOrCreateInstance(options?: {
+        acceptsInput?: boolean;
+    }): Promise<ITerminalInstance>;
+    revealActiveTerminal(preserveFocus?: boolean): Promise<void>;
+    moveToEditor(source: ITerminalInstance, group?: GroupIdentifier | SIDE_GROUP_TYPE | ACTIVE_GROUP_TYPE | AUX_WINDOW_GROUP_TYPE): void;
+    moveIntoNewEditor(source: ITerminalInstance): void;
+    moveToTerminalView(source: ITerminalInstance | URI): Promise<void>;
+    getPrimaryBackend(): ITerminalBackend | undefined;
+    /**
+    * Fire the onActiveTabChanged event, this will trigger the terminal dropdown to be updated,
+    * among other things.
+    */
+    refreshActiveGroup(): void;
+    registerProcessSupport(isSupported: boolean): void;
+    showProfileQuickPick(type: 'setDefault' | 'createInstance', cwd?: string | URI): Promise<ITerminalInstance | undefined>;
+    setContainers(panelContainer: HTMLElement, terminalContainer: HTMLElement): void;
+    requestStartExtensionTerminal(proxy: ITerminalProcessExtHostProxy, cols: number, rows: number): Promise<ITerminalLaunchError | undefined>;
+    isAttachedToTerminal(remoteTerm: IRemoteTerminalAttachTarget): boolean;
+    getEditableData(instance: ITerminalInstance): IEditableData | undefined;
+    setEditable(instance: ITerminalInstance, data: IEditableData | null): void;
+    isEditable(instance: ITerminalInstance | undefined): boolean;
+    safeDisposeTerminal(instance: ITerminalInstance): Promise<void>;
+    getDefaultInstanceHost(): ITerminalInstanceHost;
+    getInstanceHost(target: ITerminalLocationOptions | undefined): Promise<ITerminalInstanceHost>;
+    resolveLocation(location?: ITerminalLocationOptions): Promise<TerminalLocation | undefined>;
+    setNativeDelegate(nativeCalls: ITerminalServiceNativeDelegate): void;
+    getEditingTerminal(): ITerminalInstance | undefined;
+    setEditingTerminal(instance: ITerminalInstance | undefined): void;
+    /**
+    * Creates an instance event listener that listens to all instances, dynamically adding new
+    * instances and removing old instances as needed.
+    * @param getEvent Maps the instance to the event.
+    */
+    createOnInstanceEvent<T>(getEvent: (instance: ITerminalInstance) => Event<T>): Event<T>;
+    /**
+    * Creates a capability event listener that listens to capabilities on all instances,
+    * dynamically adding and removing instances and capabilities as needed.
+    * @param capabilityId The capability type to listen to an event on.
+    * @param getEvent Maps the capability to the event.
+    */
+    createOnInstanceCapabilityEvent<T extends TerminalCapability, K>(capabilityId: T, getEvent: (capability: ITerminalCapabilityImplMap[T]) => Event<K>): IDynamicListEventMultiplexer<{
+        instance: ITerminalInstance;
+        data: K;
+    }>;
+}
+declare const ITerminalInstanceService: ServiceIdentifier<ITerminalInstanceService>;
+/**
+* A service used to create instances or fetch backends, this services allows services that
+* ITerminalService depends on to also create instances.
+*
+* **This service is intended to only be used within the terminal contrib.**
+*/
+interface ITerminalInstanceService {
+    readonly _serviceBrand: undefined;
+    /**
+    * An event that's fired when a terminal instance is created.
+    */
+    onDidCreateInstance: Event<ITerminalInstance>;
+    /**
+    * Helper function to convert a shell launch config, a profile or undefined into its equivalent
+    * shell launch config.
+    * @param shellLaunchConfigOrProfile A shell launch config, a profile or undefined
+    * @param cwd A cwd to override.
+    */
+    convertProfileToShellLaunchConfig(shellLaunchConfigOrProfile?: IShellLaunchConfig | ITerminalProfile, cwd?: string | URI): IShellLaunchConfig;
+    /**
+    * Create a new terminal instance.
+    * @param launchConfig The shell launch config.
+    * @param target The target of the terminal.
+    */
+    createInstance(launchConfig: IShellLaunchConfig, target: TerminalLocation): ITerminalInstance;
+    /**
+    * Gets the registered backend for a remote authority (undefined = local). This is a convenience
+    * method to avoid using the more verbose fetching from the registry.
+    * @param remoteAuthority The remote authority of the backend.
+    */
+    getBackend(remoteAuthority?: string): Promise<ITerminalBackend | undefined>;
+    getRegisteredBackends(): IterableIterator<ITerminalBackend>;
+    didRegisterBackend(remoteAuthority?: string): void;
+}
+
+export { ITerminalInstanceService, ITerminalService };

package/vscode/src/vs/workbench/contrib/terminal/browser/terminalConfigHelper.d.ts

@@ -0,0 +1,48 @@
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.service.js';
+import { ITerminalConfiguration, ITerminalFont } from '../common/terminal.js';
+import { INotificationService } from '../../../../platform/notification/common/notification.service.js';
+import { ITerminalConfigHelper, LinuxDistro } from './terminal.js';
+import { Event } from '../../../../base/common/event.js';
+import { IExtensionManagementService } from '../../../../platform/extensionManagement/common/extensionManagement.service.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { IProductService } from '../../../../platform/product/common/productService.service.js';
+import { IXtermCore } from './xterm-private.js';
+import { IShellLaunchConfig } from '../../../../platform/terminal/common/terminal.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+
+/**
+ * Encapsulates terminal configuration logic, the primary purpose of this file is so that platform
+ * specific test cases can be written.
+ */
+declare class TerminalConfigHelper extends Disposable implements ITerminalConfigHelper {
+    private readonly _configurationService;
+    private readonly _extensionManagementService;
+    private readonly _notificationService;
+    private readonly _instantiationService;
+    private readonly _productService;
+    panelContainer: HTMLElement | undefined;
+    private _charMeasureElement;
+    private _lastFontMeasurement;
+    protected _linuxDistro: LinuxDistro;
+    config: ITerminalConfiguration;
+    private readonly _onConfigChanged;
+    get onConfigChanged(): Event<void>;
+    constructor(_configurationService: IConfigurationService, _extensionManagementService: IExtensionManagementService, _notificationService: INotificationService, _instantiationService: IInstantiationService, _productService: IProductService);
+    private _updateConfig;
+    configFontIsMonospace(): boolean;
+    private _createCharMeasureElementIfNecessary;
+    private _getBoundingRectFor;
+    private _measureFont;
+    /**
+     * Gets the font information based on the terminal.integrated.fontFamily
+     * terminal.integrated.fontSize, terminal.integrated.lineHeight configuration properties
+     */
+    getFont(w: Window, xtermCore?: IXtermCore, excludeDimensions?: boolean): ITerminalFont;
+    private _clampInt;
+    private _recommendationsShown;
+    showRecommendations(shellLaunchConfig: IShellLaunchConfig): Promise<void>;
+    private _isExtensionInstalled;
+    private _normalizeFontWeight;
+}
+
+export { TerminalConfigHelper };

package/vscode/src/vs/workbench/contrib/terminal/browser/terminalEditorInput.js

@@ -17,6 +17,7 @@ import { TerminalContextKeys } from '../common/terminalContextKey.js';
 import { IDialogService } from '../../../../platform/dialogs/common/dialogs.service.js';
 import { Emitter } from '../../../../base/common/event.js';
 var TerminalEditorInput_1;
+const _moduleId = "vs/workbench/contrib/terminal/browser/terminalEditorInput";
 let TerminalEditorInput = class TerminalEditorInput extends EditorInput {
     static { TerminalEditorInput_1 = this; }
     static { this.ID = 'workbench.editors.terminal'; }
@@ -40,7 +41,7 @@ let TerminalEditorInput = class TerminalEditorInput extends EditorInput {
     }
     setTerminalInstance(instance) {
         if (this._terminalInstance) {
-            throw new Error('cannot set instance that has already been set');
+            throw ( (new Error('cannot set instance that has already been set')));
         }
         this._terminalInstance = instance;
         this._setupInstanceListeners();
@@ -70,25 +71,17 @@ let TerminalEditorInput = class TerminalEditorInput extends EditorInput {
     async confirm(terminals) {
         const { confirmed } = await this._dialogService.confirm({
             type: Severity$1.Warning,
-            message: ( localizeWithPath(
-                'vs/workbench/contrib/terminal/browser/terminalEditorInput',
-                'confirmDirtyTerminal.message',
-                "Do you want to terminate running processes?"
-            )),
-            primaryButton: ( localizeWithPath(
-                'vs/workbench/contrib/terminal/browser/terminalEditorInput',
-                { key: 'confirmDirtyTerminal.button', comment: ['&& denotes a mnemonic'] },
-                "&&Terminate"
-            )),
+            message: ( localizeWithPath(_moduleId, 0, "Do you want to terminate running processes?")),
+            primaryButton: ( localizeWithPath(_moduleId, 1, "&&Terminate")),
             detail: terminals.length > 1 ?
-                ( terminals.map(terminal => terminal.editor.getName())).join('\n') + '\n\n' + ( localizeWithPath(
-                    'vs/workbench/contrib/terminal/browser/terminalEditorInput',
-                    'confirmDirtyTerminals.detail',
+                ( (terminals.map(terminal => terminal.editor.getName()))).join('\n') + '\n\n' + ( localizeWithPath(
+                    _moduleId,
+                    2,
                     "Closing will terminate the running processes in the terminals."
                 )) :
                 ( localizeWithPath(
-                    'vs/workbench/contrib/terminal/browser/terminalEditorInput',
-                    'confirmDirtyTerminal.detail',
+                    _moduleId,
+                    3,
                     "Closing will terminate the running processes in this terminal."
                 ))
         });
@@ -112,7 +105,7 @@ let TerminalEditorInput = class TerminalEditorInput extends EditorInput {
         this._isDetached = false;
         this._isShuttingDown = false;
         this._isReverted = false;
-        this._onDidRequestAttach = this._register(( new Emitter()));
+        this._onDidRequestAttach = this._register(( (new Emitter())));
         this.onDidRequestAttach = this._onDidRequestAttach.event;
         this._terminalEditorFocusContextKey = TerminalContextKeys.editorFocus.bindTo(_contextKeyService);
         if (_terminalInstance) {
@@ -202,13 +195,13 @@ let TerminalEditorInput = class TerminalEditorInput extends EditorInput {
         };
     }
 };
-TerminalEditorInput = TerminalEditorInput_1 = ( __decorate([
-    ( __param(2, IThemeService)),
-    ( __param(3, ITerminalInstanceService)),
-    ( __param(4, IInstantiationService)),
-    ( __param(5, IConfigurationService)),
-    ( __param(6, ILifecycleService)),
-    ( __param(7, IContextKeyService)),
-    ( __param(8, IDialogService))
-], TerminalEditorInput));
+TerminalEditorInput = TerminalEditorInput_1 = ( (__decorate([
+    ( (__param(2, IThemeService))),
+    ( (__param(3, ITerminalInstanceService))),
+    ( (__param(4, IInstantiationService))),
+    ( (__param(5, IConfigurationService))),
+    ( (__param(6, ILifecycleService))),
+    ( (__param(7, IContextKeyService))),
+    ( (__param(8, IDialogService)))
+], TerminalEditorInput)));
 export { TerminalEditorInput };

package/vscode/src/vs/workbench/contrib/terminal/browser/terminalStatusList.d.ts

@@ -0,0 +1,25 @@
+import { Event } from '../../../../base/common/event.js';
+import { ITerminalStatus } from '../common/terminal.js';
+
+interface ITerminalStatusList {
+    /** Gets the most recent, highest severity status. */
+    readonly primary: ITerminalStatus | undefined;
+    /** Gets all active statues. */
+    readonly statuses: ITerminalStatus[];
+    readonly onDidAddStatus: Event<ITerminalStatus>;
+    readonly onDidRemoveStatus: Event<ITerminalStatus>;
+    readonly onDidChangePrimaryStatus: Event<ITerminalStatus | undefined>;
+    /**
+     * Adds a status to the list.
+     * @param status The status object. Ideally a single status object that does not change will be
+     * shared as this call will no-op if the status is already set (checked by by object reference).
+     * @param duration An optional duration in milliseconds of the status, when specified the status
+     * will remove itself when the duration elapses unless the status gets re-added.
+     */
+    add(status: ITerminalStatus, duration?: number): void;
+    remove(status: ITerminalStatus): void;
+    remove(statusId: string): void;
+    toggle(status: ITerminalStatus, value: boolean): void;
+}
+
+export type { ITerminalStatusList };

package/vscode/src/vs/workbench/contrib/terminal/browser/xterm/markNavigationAddon.d.ts

@@ -0,0 +1,8 @@
+import '../../../../../editor/editor.api.js';
+
+declare const enum ScrollPosition {
+    Top = 0,
+    Middle = 1
+}
+
+export { ScrollPosition };

package/vscode/src/vs/workbench/contrib/terminal/browser/xterm/xtermTerminal.d.ts

@@ -0,0 +1,168 @@
+import { Event } from '../../../../../base/common/event.js';
+import { Terminal, ITheme } from '@xterm/xterm';
+import { CanvasAddon } from '@xterm/addon-canvas';
+import { ISearchOptions, SearchAddon } from '@xterm/addon-search';
+import { Unicode11Addon } from '@xterm/addon-unicode11';
+import { WebglAddon } from '@xterm/addon-webgl';
+import { SerializeAddon } from '@xterm/addon-serialize';
+import { ImageAddon } from '@xterm/addon-image';
+import { IConfigurationService } from '../../../../../platform/configuration/common/configuration.service.js';
+import { TerminalConfigHelper } from '../terminalConfigHelper.js';
+import { Disposable } from '../../../../../base/common/lifecycle.js';
+import { IShellIntegration } from '../../../../../platform/terminal/common/terminal.js';
+import { ITerminalLogService } from '../../../../../platform/terminal/common/terminal.service.js';
+import { ITerminalFont } from '../../common/terminal.js';
+import { IXtermTerminal, IDetachedXtermTerminal, IInternalXtermTerminal, IMarkTracker, IXtermColorProvider, IXtermAttachToElementOptions } from '../terminal.js';
+import { IStorageService } from '../../../../../platform/storage/common/storage.service.js';
+import { INotificationService } from '../../../../../platform/notification/common/notification.service.js';
+import { ScrollPosition } from './markNavigationAddon.js';
+import { IColorTheme } from '../../../../../platform/theme/common/themeService.js';
+import { IThemeService } from '../../../../../platform/theme/common/themeService.service.js';
+import { IInstantiationService } from '../../../../../platform/instantiation/common/instantiation.js';
+import { ITerminalCommand, ITerminalCapabilityStore } from '../../../../../platform/terminal/common/capabilities/capabilities.js';
+import { ITelemetryService } from '../../../../../platform/telemetry/common/telemetry.service.js';
+import { IContextKeyService } from '../../../../../platform/contextkey/common/contextkey.service.js';
+import { IClipboardService } from '../../../../../platform/clipboard/common/clipboardService.service.js';
+import { ILayoutService } from '../../../../../platform/layout/browser/layoutService.service.js';
+import { IAccessibilitySignalService } from '../../../../../platform/accessibilitySignal/browser/accessibilitySignalService.service.js';
+
+/**
+ * Wraps the xterm object with additional functionality. Interaction with the backing process is out
+ * of the scope of this class.
+ */
+declare class XtermTerminal extends Disposable implements IXtermTerminal, IDetachedXtermTerminal, IInternalXtermTerminal {
+    private readonly _configHelper;
+    private readonly _xtermColorProvider;
+    private readonly _capabilities;
+    private readonly _configurationService;
+    private readonly _instantiationService;
+    private readonly _logService;
+    private readonly _notificationService;
+    private readonly _storageService;
+    private readonly _themeService;
+    private readonly _telemetryService;
+    private readonly _clipboardService;
+    private readonly _accessibilitySignalService;
+    /** The raw xterm.js instance */
+    readonly raw: Terminal;
+    private _core;
+    private static _suggestedRendererType;
+    private static _checkedWebglCompatible;
+    private _attached?;
+    private _isPhysicalMouseWheel;
+    private _markNavigationAddon;
+    private _shellIntegrationAddon;
+    private _decorationAddon;
+    private _canvasAddon?;
+    private _searchAddon?;
+    private _unicode11Addon?;
+    private _webglAddon?;
+    private _serializeAddon?;
+    private _imageAddon?;
+    private readonly _attachedDisposables;
+    private readonly _anyTerminalFocusContextKey;
+    private readonly _anyFocusedTerminalHasSelection;
+    private _lastFindResult;
+    get findResult(): {
+        resultIndex: number;
+        resultCount: number;
+    } | undefined;
+    get isStdinDisabled(): boolean;
+    get isGpuAccelerated(): boolean;
+    private readonly _onDidRequestRunCommand;
+    readonly onDidRequestRunCommand: Event<{
+        command: ITerminalCommand;
+        copyAsHtml?: boolean | undefined;
+        noNewLine?: boolean | undefined;
+    }>;
+    private readonly _onDidRequestFocus;
+    readonly onDidRequestFocus: Event<void>;
+    private readonly _onDidRequestSendText;
+    readonly onDidRequestSendText: Event<string>;
+    private readonly _onDidRequestFreePort;
+    readonly onDidRequestFreePort: Event<string>;
+    private readonly _onDidChangeFindResults;
+    readonly onDidChangeFindResults: Event<{
+        resultIndex: number;
+        resultCount: number;
+    }>;
+    private readonly _onDidChangeSelection;
+    readonly onDidChangeSelection: Event<void>;
+    private readonly _onDidChangeFocus;
+    readonly onDidChangeFocus: Event<boolean>;
+    private readonly _onDidDispose;
+    readonly onDidDispose: Event<void>;
+    get markTracker(): IMarkTracker;
+    get shellIntegration(): IShellIntegration;
+    get textureAtlas(): Promise<ImageBitmap> | undefined;
+    get isFocused(): boolean;
+    /**
+     * @param xtermCtor The xterm.js constructor, this is passed in so it can be fetched lazily
+     * outside of this class such that {@link raw} is not nullable.
+     */
+    constructor(xtermCtor: typeof Terminal, _configHelper: TerminalConfigHelper, cols: number, rows: number, _xtermColorProvider: IXtermColorProvider, _capabilities: ITerminalCapabilityStore, shellIntegrationNonce: string, disableShellIntegrationReporting: boolean, _configurationService: IConfigurationService, _instantiationService: IInstantiationService, _logService: ITerminalLogService, _notificationService: INotificationService, _storageService: IStorageService, _themeService: IThemeService, _telemetryService: ITelemetryService, _clipboardService: IClipboardService, contextKeyService: IContextKeyService, _accessibilitySignalService: IAccessibilitySignalService, layoutService: ILayoutService);
+    getBufferReverseIterator(): IterableIterator<string>;
+    getContentsAsHtml(): Promise<string>;
+    getSelectionAsHtml(command?: ITerminalCommand): Promise<string>;
+    attachToElement(container: HTMLElement, partialOptions?: Partial<IXtermAttachToElementOptions>): HTMLElement;
+    private _setFocused;
+    write(data: string | Uint8Array, callback?: () => void): void;
+    resize(columns: number, rows: number): void;
+    updateConfig(): void;
+    private _updateSmoothScrolling;
+    private _shouldLoadWebgl;
+    private _shouldLoadCanvas;
+    forceRedraw(): void;
+    clearDecorations(): void;
+    forceRefresh(): void;
+    forceUnpause(): void;
+    findNext(term: string, searchOptions: ISearchOptions): Promise<boolean>;
+    findPrevious(term: string, searchOptions: ISearchOptions): Promise<boolean>;
+    private _updateFindColors;
+    private _searchAddonPromise;
+    private _getSearchAddon;
+    clearSearchDecorations(): void;
+    clearActiveSearchDecoration(): void;
+    getFont(): ITerminalFont;
+    getLongestViewportWrappedLineLength(): number;
+    private _getWrappedLineCount;
+    scrollDownLine(): void;
+    scrollDownPage(): void;
+    scrollToBottom(): void;
+    scrollUpLine(): void;
+    scrollUpPage(): void;
+    scrollToTop(): void;
+    scrollToLine(line: number, position?: ScrollPosition): void;
+    clearBuffer(): void;
+    hasSelection(): boolean;
+    clearSelection(): void;
+    selectMarkedRange(fromMarkerId: string, toMarkerId: string, scrollIntoView?: boolean): void;
+    selectAll(): void;
+    focus(): void;
+    copySelection(asHtml?: boolean, command?: ITerminalCommand): Promise<void>;
+    private _setCursorBlink;
+    private _setCursorStyle;
+    private _setCursorStyleInactive;
+    private _setCursorWidth;
+    private _enableWebglRenderer;
+    private _disableWebglForThisSession;
+    private _enableCanvasRenderer;
+    protected _getCanvasAddonConstructor(): Promise<typeof CanvasAddon>;
+    private _refreshImageAddon;
+    protected _getImageAddonConstructor(): Promise<typeof ImageAddon>;
+    protected _getSearchAddonConstructor(): Promise<typeof SearchAddon>;
+    protected _getUnicode11Constructor(): Promise<typeof Unicode11Addon>;
+    protected _getWebglAddonConstructor(): Promise<typeof WebglAddon>;
+    protected _getSerializeAddonConstructor(): Promise<typeof SerializeAddon>;
+    private _disposeOfCanvasRenderer;
+    private _disposeOfWebglRenderer;
+    private _measureRenderTime;
+    getXtermTheme(theme?: IColorTheme): ITheme;
+    private _updateTheme;
+    refresh(): void;
+    private _updateUnicodeVersion;
+    _writeText(data: string): void;
+    dispose(): void;
+}
+
+export { XtermTerminal };

package/vscode/src/vs/workbench/contrib/terminal/browser/xterm-private.d.ts

@@ -0,0 +1,55 @@
+import { IBufferCell } from '@xterm/xterm';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+
+
+type XtermAttributes = Omit<IBufferCell, 'getWidth' | 'getChars' | 'getCode'> & { clone?(): XtermAttributes };
+
+interface IXtermCore {
+	viewport?: {
+		readonly scrollBarWidth: number;
+		_innerRefresh(): void;
+	};
+	_onData: IEventEmitter<string>;
+	_onKey: IEventEmitter<{ key: string }>;
+
+	_charSizeService: {
+		width: number;
+		height: number;
+	};
+
+	coreService: {
+		triggerDataEvent(data: string, wasUserInput?: boolean): void;
+	};
+
+	_inputHandler: {
+		_curAttrData: XtermAttributes;
+	};
+
+	_renderService: {
+		dimensions: {
+			css: {
+				cell: {
+					width: number;
+					height: number;
+				}
+			}
+		},
+		_renderer: {
+			value?: {
+				_renderLayers?: any[];
+			}
+		};
+		_handleIntersectionChange: any;
+	};
+}
+
+interface IEventEmitter<T> {
+	fire(e: T): void;
+}
+
+export type { IEventEmitter, IXtermCore, XtermAttributes };

package/vscode/src/vs/workbench/contrib/terminal/common/environmentVariable.d.ts

@@ -0,0 +1,9 @@
+import { EnvironmentVariableScope } from '../../../../platform/terminal/common/environmentVariable.js';
+import { ITerminalStatus } from './terminal.js';
+
+interface IEnvironmentVariableInfo {
+    readonly requiresAction: boolean;
+    getStatus(scope: EnvironmentVariableScope | undefined): ITerminalStatus;
+}
+
+export type { IEnvironmentVariableInfo };