@theia/plugin 1.51.0 → 1.53.0-next.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@theia/plugin",
-  "version": "1.51.0",
+  "version": "1.53.0-next.18+c3ffc5fa8",
   "description": "Theia - Plugin API",
   "types": "./src/theia.d.ts",
   "publishConfig": {
@@ -27,10 +27,10 @@
     "watch": "theiaext watch"
   },
   "devDependencies": {
-    "@theia/ext-scripts": "1.51.0"
+    "@theia/ext-scripts": "1.52.0"
   },
   "nyc": {
     "extends": "../../configs/nyc.json"
   },
-  "gitHead": "fe70ec5d445d733038564d81357c78aedf5c7e0e"
+  "gitHead": "c3ffc5fa81879943e3b3ad3caec3738ed2d0e5f9"
 }

package/src/theia.d.ts

@@ -24,23 +24,26 @@
 import './theia-extra';
 import './theia.proposed.canonicalUriProvider';
 import './theia.proposed.customEditorMove';
+import './theia.proposed.debugVisualization';
 import './theia.proposed.diffCommand';
 import './theia.proposed.documentPaste';
 import './theia.proposed.editSessionIdentityProvider';
 import './theia.proposed.extensionsAny';
 import './theia.proposed.externalUriOpener';
+import './theia.proposed.findTextInFiles';
+import './theia.proposed.fsChunks';
 import './theia.proposed.mappedEditsProvider';
+import './theia.proposed.multiDocumentHighlightProvider';
 import './theia.proposed.notebookCellExecutionState';
 import './theia.proposed.notebookKernelSource';
 import './theia.proposed.notebookMessaging';
-import './theia.proposed.findTextInFiles';
-import './theia.proposed.fsChunks';
-import './theia.proposed.multiDocumentHighlightProvider';
+import './theia.proposed.portsAttributes';
 import './theia.proposed.profileContentHandlers';
 import './theia.proposed.resolvers';
 import './theia.proposed.scmValidation';
 import './theia.proposed.shareProvider';
 import './theia.proposed.terminalQuickFixProvider';
+import './theia.proposed.terminalShellIntegration';
 import './theia.proposed.textSearchProvider';
 import './theia.proposed.timeline';
 
@@ -3172,7 +3175,7 @@ export module '@theia/plugin' {
         /**
          * The icon path or {@link ThemeIcon} for the terminal.
          */
-        iconPath?: ThemeIcon;
+        iconPath?: Uri | { light: Uri; dark: Uri } | ThemeIcon;
 
         /**
          * The icon {@link ThemeColor} for the terminal.
@@ -3293,7 +3296,7 @@ export module '@theia/plugin' {
         /**
          * The icon path or {@link ThemeIcon} for the terminal.
          */
-        iconPath?: ThemeIcon;
+        iconPath?: Uri | { light: Uri; dark: Uri } | ThemeIcon;
 
         /**
          * The icon {@link ThemeColor} for the terminal.
@@ -12085,6 +12088,12 @@ export module '@theia/plugin' {
          * When true, the debug viewlet will not be automatically revealed for this session.
          */
         suppressDebugView?: boolean;
+        /**
+         * Signals to the editor that the debug session was started from a test run
+         * request. This is used to link the lifecycle of the debug session and
+         * test run in UI actions.
+         */
+        testRun?: TestRun;
     }
 
     /**
@@ -12546,13 +12555,11 @@ export module '@theia/plugin' {
          * thread or stack is focused. A thread can be focused any time there is
          * an active debug session, while a stack frame can only be focused when
          * a session is paused and the call stack has been retrieved.
-         * @stubbed
          */
         export const activeStackItem: DebugThread | DebugStackFrame | undefined;
 
         /**
          * An event which fires when the {@link debug.activeStackItem} has changed.
-         * @stubbed
          */
         export const onDidChangeActiveStackItem: Event<DebugThread | DebugStackFrame | undefined>;
 

package/src/theia.proposed.debugVisualization.d.ts

@@ -0,0 +1,189 @@
+// *****************************************************************************
+// Copyright (C) 2024 Typefox and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+declare module '@theia/plugin' {
+    export namespace debug {
+        /**
+         * Registers a custom data visualization for variables when debugging.
+         *
+         * @param id The corresponding ID in the package.json `debugVisualizers` contribution point.
+         * @param provider The {@link DebugVisualizationProvider} to register
+         * @stubbed
+         */
+        export function registerDebugVisualizationProvider<T extends DebugVisualization>(
+            id: string,
+            provider: DebugVisualizationProvider<T>
+        ): Disposable;
+
+        /**
+         * Registers a tree that can be referenced by {@link DebugVisualization.visualization}.
+         * @param id
+         * @param provider
+         * @stubbed
+         */
+        export function registerDebugVisualizationTreeProvider<T extends DebugTreeItem>(
+            id: string,
+            provider: DebugVisualizationTree<T>
+        ): Disposable;
+    }
+
+    /**
+     * An item from the {@link DebugVisualizationTree}
+     */
+    export interface DebugTreeItem {
+        /**
+         * A human-readable string describing this item.
+         */
+        label: string;
+
+        /**
+         * A human-readable string which is rendered less prominent.
+         */
+        description?: string;
+
+        /**
+         * {@link TreeItemCollapsibleState} of the tree item.
+         */
+        collapsibleState?: TreeItemCollapsibleState;
+
+        /**
+         * Context value of the tree item. This can be used to contribute item specific actions in the tree.
+         * For example, a tree item is given a context value as `folder`. When contributing actions to `view/item/context`
+         * using `menus` extension point, you can specify context value for key `viewItem` in `when` expression like `viewItem == folder`.
+         * ```json
+         * "contributes": {
+         *   "menus": {
+         *     "view/item/context": [
+         *       {
+         *         "command": "extension.deleteFolder",
+         *         "when": "viewItem == folder"
+         *       }
+         *     ]
+         *   }
+         * }
+         * ```
+         * This will show action `extension.deleteFolder` only for items with `contextValue` is `folder`.
+         */
+        contextValue?: string;
+
+        /**
+         * Whether this item can be edited by the user.
+         */
+        canEdit?: boolean;
+    }
+
+    /**
+     * Provides a tree that can be referenced in debug visualizations.
+     */
+    export interface DebugVisualizationTree<T extends DebugTreeItem = DebugTreeItem> {
+        /**
+         * Gets the tree item for an element or the base context item.
+         */
+        getTreeItem(context: DebugVisualizationContext): ProviderResult<T>;
+        /**
+         * Gets children for the tree item or the best context item.
+         */
+        getChildren(element: T): ProviderResult<T[]>;
+        /**
+         * Handles the user editing an item.
+         */
+        editItem?(item: T, value: string): ProviderResult<T>;
+    }
+
+    export class DebugVisualization {
+        /**
+         * The name of the visualization to show to the user.
+         */
+        name: string;
+
+        /**
+         * An icon for the view when it's show in inline actions.
+         */
+        iconPath?: Uri | { light: Uri; dark: Uri } | ThemeIcon;
+
+        /**
+         * Visualization to use for the variable. This may be either:
+         * - A command to run when the visualization is selected for a variable.
+         * - A reference to a previously-registered {@link DebugVisualizationTree}
+         */
+        visualization?: Command | { treeId: string };
+
+        /**
+         * Creates a new debug visualization object.
+         * @param name Name of the visualization to show to the user.
+         */
+        constructor(name: string);
+    }
+
+    export interface DebugVisualizationProvider<T extends DebugVisualization = DebugVisualization> {
+        /**
+         * Called for each variable when the debug session stops. It should return
+         * any visualizations the extension wishes to show to the user.
+         *
+         * Note that this is only called when its `when` clause defined under the
+         * `debugVisualizers` contribution point in the `package.json` evaluates
+         * to true.
+         */
+        provideDebugVisualization(context: DebugVisualizationContext, token: CancellationToken): ProviderResult<T[]>;
+
+        /**
+         * Invoked for a variable when a user picks the visualizer.
+         *
+         * It may return a {@link TreeView} that's shown in the Debug Console or
+         * inline in a hover. A visualizer may choose to return `undefined` from
+         * this function and instead trigger other actions in the UI, such as opening
+         * a custom {@link WebviewView}.
+         */
+        resolveDebugVisualization?(visualization: T, token: CancellationToken): ProviderResult<T>;
+    }
+
+    export interface DebugVisualizationContext {
+        /**
+         * The Debug Adapter Protocol Variable to be visualized.
+         * @see https://microsoft.github.io/debug-adapter-protocol/specification#Types_Variable
+         */
+        variable: any;
+        /**
+         * The Debug Adapter Protocol variable reference the type (such as a scope
+         * or another variable) that contained this one. Empty for variables
+         * that came from user evaluations in the Debug Console.
+         * @see https://microsoft.github.io/debug-adapter-protocol/specification#Types_Variable
+         */
+        containerId?: number;
+        /**
+         * The ID of the Debug Adapter Protocol StackFrame in which the variable was found,
+         * for variables that came from scopes in a stack frame.
+         * @see https://microsoft.github.io/debug-adapter-protocol/specification#Types_StackFrame
+         */
+        frameId?: number;
+        /**
+         * The ID of the Debug Adapter Protocol Thread in which the variable was found.
+         * @see https://microsoft.github.io/debug-adapter-protocol/specification#Types_StackFrame
+         */
+        threadId: number;
+        /**
+         * The debug session the variable belongs to.
+         */
+        session: DebugSession;
+    }
+}

package/src/theia.proposed.portsAttributes.d.ts

@@ -0,0 +1,115 @@
+// *****************************************************************************
+// Copyright (C) 2024 Typefox and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+declare module '@theia/plugin' {
+
+    /**
+     * The action that should be taken when a port is discovered through automatic port forwarding discovery.
+     */
+    export enum PortAutoForwardAction {
+        /**
+         * Notify the user that the port is being forwarded. This is the default action.
+         */
+        Notify = 1,
+        /**
+         * Once the port is forwarded, open the user's web browser to the forwarded port.
+         */
+        OpenBrowser = 2,
+        /**
+         * Once the port is forwarded, open the preview browser to the forwarded port.
+         */
+        OpenPreview = 3,
+        /**
+         * Forward the port silently.
+         */
+        Silent = 4,
+        /**
+         * Do not forward the port.
+         */
+        Ignore = 5
+    }
+
+    /**
+     * The attributes that a forwarded port can have.
+     */
+    export class PortAttributes {
+        /**
+         * The action to be taken when this port is detected for auto forwarding.
+         */
+        autoForwardAction: PortAutoForwardAction;
+
+        /**
+         * Creates a new PortAttributes object
+         * @param port the port number
+         * @param autoForwardAction the action to take when this port is detected
+         */
+        constructor(autoForwardAction: PortAutoForwardAction);
+    }
+
+    /**
+     * A provider of port attributes. Port attributes are used to determine what action should be taken when a port is discovered.
+     */
+    export interface PortAttributesProvider {
+        /**
+         * Provides attributes for the given port. For ports that your extension doesn't know about, simply
+         * return undefined. For example, if `providePortAttributes` is called with ports 3000 but your
+         * extension doesn't know anything about 3000 you should return undefined.
+         * @param port The port number of the port that attributes are being requested for.
+         * @param pid The pid of the process that is listening on the port. If the pid is unknown, undefined will be passed.
+         * @param commandLine The command line of the process that is listening on the port. If the command line is unknown, undefined will be passed.
+         * @param token A cancellation token that indicates the result is no longer needed.
+         */
+        providePortAttributes(attributes: { port: number; pid?: number; commandLine?: string }, token: CancellationToken): ProviderResult<PortAttributes>;
+    }
+
+    /**
+     * A selector that will be used to filter which {@link PortAttributesProvider} should be called for each port.
+     */
+    export interface PortAttributesSelector {
+        /**
+         * Specifying a port range will cause your provider to only be called for ports within the range.
+         * The start is inclusive and the end is exclusive.
+         */
+        portRange?: [number, number] | number;
+
+        /**
+         * Specifying a command pattern will cause your provider to only be called for processes whose command line matches the pattern.
+         */
+        commandPattern?: RegExp;
+    }
+
+    export namespace workspace {
+        /**
+         * If your extension listens on ports, consider registering a PortAttributesProvider to provide information
+         * about the ports. For example, a debug extension may know about debug ports in it's debuggee. By providing
+         * this information with a PortAttributesProvider the extension can tell the editor that these ports should be
+         * ignored, since they don't need to be user facing.
+         *
+         * The results of the PortAttributesProvider are merged with the user setting `remote.portsAttributes`. If the values conflict, the user setting takes precedence.
+         *
+         * @param portSelector It is best practice to specify a port selector to avoid unnecessary calls to your provider.
+         * If you don't specify a port selector your provider will be called for every port, which will result in slower port forwarding for the user.
+         * @param provider The {@link PortAttributesProvider PortAttributesProvider}.
+         * @stubbed
+         */
+        export function registerPortAttributesProvider(portSelector: PortAttributesSelector, provider: PortAttributesProvider): Disposable;
+    }
+}

package/src/theia.proposed.terminalShellIntegration.d.ts

@@ -0,0 +1,329 @@
+// *****************************************************************************
+// Copyright (C) 2024 Typefox and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+declare module '@theia/plugin' {
+
+    // https://github.com/microsoft/vscode/issues/145234
+
+    /**
+     * A command that was executed in a terminal.
+     */
+    export interface TerminalShellExecution {
+        /**
+         * The command line that was executed. The {@link TerminalShellExecutionCommandLineConfidence confidence}
+         * of this value depends on the specific shell's shell integration implementation. This
+         * value may become more accurate after {@link window.onDidEndTerminalShellExecution} is
+         * fired.
+         *
+         * @example
+         * // Log the details of the command line on start and end
+         * window.onDidStartTerminalShellExecution(event => {
+         *   const commandLine = event.execution.commandLine;
+         *   console.log(`Command started\n${summarizeCommandLine(commandLine)}`);
+         * });
+         * window.onDidEndTerminalShellExecution(event => {
+         *   const commandLine = event.execution.commandLine;
+         *   console.log(`Command ended\n${summarizeCommandLine(commandLine)}`);
+         * });
+         * function summarizeCommandLine(commandLine: TerminalShellExecutionCommandLine) {
+         *   return [
+         *     `  Command line: ${command.ommandLine.value}`,
+         *     `  Confidence: ${command.ommandLine.confidence}`,
+         *     `  Trusted: ${command.ommandLine.isTrusted}
+         *   ].join('\n');
+         * }
+         */
+        readonly commandLine: TerminalShellExecutionCommandLine;
+
+        /**
+         * The working directory that was reported by the shell when this command executed. This
+         * {@link Uri} may represent a file on another machine (eg. ssh into another machine). This
+         * requires the shell integration to support working directory reporting.
+         */
+        readonly cwd: Uri | undefined;
+
+        /**
+         * Creates a stream of raw data (including escape sequences) that is written to the
+         * terminal. This will only include data that was written after `read` was called for
+         * the first time, ie. you must call `read` immediately after the command is executed via
+         * {@link TerminalShellIntegration.executeCommand} or
+         * {@link window.onDidStartTerminalShellExecution} to not miss any data.
+         *
+         * @example
+         * // Log all data written to the terminal for a command
+         * const command = term.shellIntegration.executeCommand({ commandLine: 'echo "Hello world"' });
+         * const stream = command.read();
+         * for await (const data of stream) {
+         *   console.log(data);
+         * }
+         */
+        read(): AsyncIterable<string>;
+    }
+
+    /**
+     * A command line that was executed in a terminal.
+     */
+    export interface TerminalShellExecutionCommandLine {
+        /**
+         * The full command line that was executed, including both the command and its arguments.
+         */
+        readonly value: string;
+
+        /**
+         * Whether the command line value came from a trusted source and is therefore safe to
+         * execute without user additional confirmation, such as a notification that asks "Do you
+         * want to execute (command)?". This verification is likely only needed if you are going to
+         * execute the command again.
+         *
+         * This is `true` only when the command line was reported explicitly by the shell
+         * integration script (ie. {@link TerminalShellExecutionCommandLineConfidence.High high confidence})
+         * and it used a nonce for verification.
+         */
+        readonly isTrusted: boolean;
+
+        /**
+         * The confidence of the command line value which is determined by how the value was
+         * obtained. This depends upon the implementation of the shell integration script.
+         */
+        readonly confidence: TerminalShellExecutionCommandLineConfidence;
+    }
+
+    /**
+     * The confidence of a {@link TerminalShellExecutionCommandLine} value.
+     */
+    enum TerminalShellExecutionCommandLineConfidence {
+        /**
+         * The command line value confidence is low. This means that the value was read from the
+         * terminal buffer using markers reported by the shell integration script. Additionally one
+         * of the following conditions will be met:
+         *
+         * - The command started on the very left-most column which is unusual, or
+         * - The command is multi-line which is more difficult to accurately detect due to line
+         *   continuation characters and right prompts.
+         * - Command line markers were not reported by the shell integration script.
+         */
+        Low = 0,
+
+        /**
+         * The command line value confidence is medium. This means that the value was read from the
+         * terminal buffer using markers reported by the shell integration script. The command is
+         * single-line and does not start on the very left-most column (which is unusual).
+         */
+        Medium = 1,
+
+        /**
+         * The command line value confidence is high. This means that the value was explicitly sent
+         * from the shell integration script or the command was executed via the
+         * {@link TerminalShellIntegration.executeCommand} API.
+         */
+        High = 2
+    }
+
+    export interface Terminal {
+        /**
+         * An object that contains [shell integration](https://code.visualstudio.com/docs/terminal/shell-integration)-powered
+         * features for the terminal. This will always be `undefined` immediately after the terminal
+         * is created. Listen to {@link window.onDidActivateTerminalShellIntegration} to be notified
+         * when shell integration is activated for a terminal.
+         *
+         * Note that this object may remain undefined if shell integation never activates. For
+         * example Command Prompt does not support shell integration and a user's shell setup could
+         * conflict with the automatic shell integration activation.
+         */
+        readonly shellIntegration: TerminalShellIntegration | undefined;
+    }
+
+    /**
+     * [Shell integration](https://code.visualstudio.com/docs/terminal/shell-integration)-powered capabilities owned by a terminal.
+     */
+    export interface TerminalShellIntegration {
+        /**
+         * The current working directory of the terminal. This {@link Uri} may represent a file on
+         * another machine (eg. ssh into another machine). This requires the shell integration to
+         * support working directory reporting.
+         */
+        readonly cwd: Uri | undefined;
+
+        /**
+         * Execute a command, sending ^C as necessary to interrupt any running command if needed.
+         *
+         * @param commandLine The command line to execute, this is the exact text that will be sent
+         * to the terminal.
+         *
+         * @example
+         * // Execute a command in a terminal immediately after being created
+         * const myTerm = window.createTerminal();
+         * window.onDidActivateTerminalShellIntegration(async ({ terminal, shellIntegration }) => {
+         *   if (terminal === myTerm) {
+         *     const command = shellIntegration.executeCommand('echo "Hello world"');
+         *     const code = await command.exitCode;
+         *     console.log(`Command exited with code ${code}`);
+         *   }
+         * }));
+         * // Fallback to sendText if there is no shell integration within 3 seconds of launching
+         * setTimeout(() => {
+         *   if (!myTerm.shellIntegration) {
+         *     myTerm.sendText('echo "Hello world"');
+         *     // Without shell integration, we can't know when the command has finished or what the
+         *     // exit code was.
+         *   }
+         * }, 3000);
+         *
+         * @example
+         * // Send command to terminal that has been alive for a while
+         * const commandLine = 'echo "Hello world"';
+         * if (term.shellIntegration) {
+         *   const command = term.shellIntegration.executeCommand({ commandLine });
+         *   const code = await command.exitCode;
+         *   console.log(`Command exited with code ${code}`);
+         * } else {
+         *   term.sendText(commandLine);
+         *   // Without shell integration, we can't know when the command has finished or what the
+         *   // exit code was.
+         * }
+         */
+        executeCommand(commandLine: string): TerminalShellExecution;
+
+        /**
+         * Execute a command, sending ^C as necessary to interrupt any running command if needed.
+         *
+         * *Note* This is not guaranteed to work as [shell integration](https://code.visualstudio.com/docs/terminal/shell-integration)
+         * must be activated. Check whether {@link TerminalShellExecution.exitCode} is rejected to
+         * verify whether it was successful.
+         *
+         * @param command A command to run.
+         * @param args Arguments to launch the executable with which will be automatically escaped
+         * based on the executable type.
+         *
+         * @example
+         * // Execute a command in a terminal immediately after being created
+         * const myTerm = window.createTerminal();
+         * window.onDidActivateTerminalShellIntegration(async ({ terminal, shellIntegration }) => {
+         *   if (terminal === myTerm) {
+         *     const command = shellIntegration.executeCommand({
+         *       command: 'echo',
+         *       args: ['Hello world']
+         *     });
+         *     const code = await command.exitCode;
+         *     console.log(`Command exited with code ${code}`);
+         *   }
+         * }));
+         * // Fallback to sendText if there is no shell integration within 3 seconds of launching
+         * setTimeout(() => {
+         *   if (!myTerm.shellIntegration) {
+         *     myTerm.sendText('echo "Hello world"');
+         *     // Without shell integration, we can't know when the command has finished or what the
+         *     // exit code was.
+         *   }
+         * }, 3000);
+         *
+         * @example
+         * // Send command to terminal that has been alive for a while
+         * const commandLine = 'echo "Hello world"';
+         * if (term.shellIntegration) {
+         *   const command = term.shellIntegration.executeCommand({
+         *     command: 'echo',
+         *     args: ['Hello world']
+         *   });
+         *   const code = await command.exitCode;
+         *   console.log(`Command exited with code ${code}`);
+         * } else {
+         *   term.sendText(commandLine);
+         *   // Without shell integration, we can't know when the command has finished or what the
+         *   // exit code was.
+         * }
+         */
+        executeCommand(executable: string, args: string[]): TerminalShellExecution;
+    }
+
+    export interface TerminalShellIntegrationChangeEvent {
+        /**
+         * The terminal that shell integration has been activated in.
+         */
+        readonly terminal: Terminal;
+
+        /**
+         * The shell integration object.
+         */
+        readonly shellIntegration: TerminalShellIntegration;
+    }
+
+    export interface TerminalShellExecutionStartEvent {
+        /**
+         * The terminal that shell integration has been activated in.
+         */
+        readonly terminal: Terminal;
+
+        /**
+         * The shell integration object.
+         */
+        readonly shellIntegration: TerminalShellIntegration;
+
+        /**
+         * The terminal shell execution that has ended.
+         */
+        readonly execution: TerminalShellExecution;
+    }
+
+    export interface TerminalShellExecutionEndEvent {
+        /**
+         * The terminal that shell integration has been activated in.
+         */
+        readonly terminal: Terminal;
+
+        /**
+         * The shell integration object.
+         */
+        readonly shellIntegration: TerminalShellIntegration;
+
+        /**
+         * The terminal shell execution that has ended.
+         */
+        readonly execution: TerminalShellExecution;
+
+        /**
+         * The exit code reported by the shell. `undefined` means the shell did not report an exit
+         * code or the shell reported a command started before the command finished.
+         */
+        readonly exitCode: number | undefined;
+    }
+
+    export namespace window {
+        /**
+         * Fires when shell integration activates or one of its properties changes in a terminal.
+         */
+        export const onDidChangeTerminalShellIntegration: Event<TerminalShellIntegrationChangeEvent>;
+
+        /**
+         * This will be fired when a terminal command is started. This event will fire only when
+         * [shell integration](https://code.visualstudio.com/docs/terminal/shell-integration) is
+         * activated for the terminal.
+         */
+        export const onDidStartTerminalShellExecution: Event<TerminalShellExecutionStartEvent>;
+
+        /**
+         * This will be fired when a terminal command is ended. This event will fire only when
+         * [shell integration](https://code.visualstudio.com/docs/terminal/shell-integration) is
+         * activated for the terminal.
+         */
+        export const onDidEndTerminalShellExecution: Event<TerminalShellExecutionEndEvent>;
+    }
+}