@theia/plugin 1.53.2 → 1.55.0-next.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@theia/plugin",
-  "version": "1.53.2",
+  "version": "1.55.0-next.4+f6ace675e",
   "description": "Theia - Plugin API",
   "types": "./src/theia.d.ts",
   "publishConfig": {
@@ -27,10 +27,10 @@
     "watch": "theiaext watch"
   },
   "devDependencies": {
-    "@theia/ext-scripts": "1.53.2"
+    "@theia/ext-scripts": "1.54.0"
   },
   "nyc": {
     "extends": "../../configs/nyc.json"
   },
-  "gitHead": "4f6f158bd27c5dd608dddc036910698a51d8c953"
+  "gitHead": "f6ace675e712c3d2227d1cd19e9c905a6e4d9ad6"
 }

package/src/theia.d.ts

@@ -43,7 +43,6 @@ 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';
 
@@ -3058,6 +3057,19 @@ export module '@theia/plugin' {
          */
         readonly state: TerminalState;
 
+        /**
+         * 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.onDidChangeTerminalShellIntegration} 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.
+         * @stubbed
+         */
+        readonly shellIntegration: TerminalShellIntegration | undefined;
+
         /**
          * Send text to the terminal.
          * @param text - The text to send.
@@ -3101,6 +3113,333 @@ export module '@theia/plugin' {
         readonly isInteractedWith: boolean;
     }
 
+    /**
+     * [Shell integration](https://code.visualstudio.com/docs/terminal/shell-integration)-powered capabilities owned by a terminal.
+     * @stubbed
+     */
+    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.
+         * @stubbed
+         */
+        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.onDidChangeTerminalShellIntegration(async ({ terminal, shellIntegration }) => {
+         *   if (terminal === myTerm) {
+         *     const execution = shellIntegration.executeCommand('echo "Hello world"');
+         *     window.onDidEndTerminalShellExecution(event => {
+         *     if (event.execution === execution) {
+         *       console.log(`Command exited with code ${event.exitCode}`);
+         *     }
+         *   }
+         * }));
+         * // 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 execution = shellIntegration.executeCommand({ commandLine });
+         *   window.onDidEndTerminalShellExecution(event => {
+         *   if (event.execution === execution) {
+         *     console.log(`Command exited with code ${event.exitCode}`);
+         *   }
+         * } else {
+         *   term.sendText(commandLine);
+         *   // Without shell integration, we can't know when the command has finished or what the
+         *   // exit code was.
+         * }
+         * @stubbed
+         */
+        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.
+         * }
+         * @stubbed
+         */
+        executeCommand(executable: string, args: string[]): TerminalShellExecution;
+    }
+
+    /**
+     * A command that was executed in a terminal.
+     * @stubbed
+     */
+    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.commandLine.value}`,
+         *     `  Confidence: ${command.commandLine.confidence}`,
+         *     `  Trusted: ${command.commandLine.isTrusted}
+         *   ].join('\n');
+         * }
+         * @stubbed
+         */
+        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.
+         * @stubbed
+         */
+        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);
+         * }
+         * @stubbed
+         */
+        read(): AsyncIterable<string>;
+    }
+
+    /**
+     * A command line that was executed in a terminal.
+     * @stubbed
+     */
+    export interface TerminalShellExecutionCommandLine {
+        /**
+         * The full command line that was executed, including both the command and its arguments.
+         * @stubbed
+         */
+        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.
+         * @stubbed
+         */
+        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.
+         * @stubbed
+         */
+        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
+    }
+
+    /**
+     * An event signalling that a terminal's shell integration has changed.
+     * @stubbed
+     */
+    export interface TerminalShellIntegrationChangeEvent {
+        /**
+         * The terminal that shell integration has been activated in.
+         * @stubbed
+         */
+        readonly terminal: Terminal;
+
+        /**
+         * The shell integration object.
+         * @stubbed
+         */
+        readonly shellIntegration: TerminalShellIntegration;
+    }
+
+    /**
+     * An event signalling that an execution has started in a terminal.
+     * @stubbed
+     */
+    export interface TerminalShellExecutionStartEvent {
+        /**
+         * The terminal that shell integration has been activated in.
+         * @stubbed
+         */
+        readonly terminal: Terminal;
+
+        /**
+         * The shell integration object.
+         * @stubbed
+         */
+        readonly shellIntegration: TerminalShellIntegration;
+
+        /**
+         * The terminal shell execution that has ended.
+         * @stubbed
+         */
+        readonly execution: TerminalShellExecution;
+    }
+
+    /**
+     * An event signalling that an execution has ended in a terminal.
+     * @stubbed
+     */
+    export interface TerminalShellExecutionEndEvent {
+        /**
+         * The terminal that shell integration has been activated in.
+         * @stubbed
+         */
+        readonly terminal: Terminal;
+
+        /**
+         * The shell integration object.
+         * @stubbed
+         */
+        readonly shellIntegration: TerminalShellIntegration;
+
+        /**
+         * The terminal shell execution that has ended.
+         * @stubbed
+         */
+        readonly execution: TerminalShellExecution;
+
+        /**
+         * The exit code reported by the shell.
+         *
+         * Note that `undefined` means the shell either did not report an exit  code (ie. the shell
+         * integration script is misbehaving) or the shell reported a command started before the command
+         * finished (eg. a sub-shell was opened). Generally this should not happen, depending on the use
+         * case, it may be best to treat this as a failure.
+         *
+         * @example
+         * const execution = shellIntegration.executeCommand({
+         *   command: 'echo',
+         *   args: ['Hello world']
+         * });
+         * window.onDidEndTerminalShellExecution(event => {
+         *   if (event.execution === execution) {
+         *     if (event.exitCode === undefined) {
+         *      console.log('Command finished but exit code is unknown');
+         *     } else if (event.exitCode === 0) {
+         *      console.log('Command succeeded');
+         *     } else {
+         *      console.log('Command failed');
+         *     }
+         *   }
+         * });
+         * @stubbed
+         */
+        readonly exitCode: number | undefined;
+    }
+
     /**
      * Options to create terminal widget.
      */
@@ -3181,7 +3520,6 @@ export module '@theia/plugin' {
          * The icon {@link ThemeColor} for the terminal.
          * The `terminal.ansi*` theme keys are
          * recommended for the best contrast and consistency across themes.
-         * @stubbed
          */
         color?: ThemeColor;
     }
@@ -5500,6 +5838,28 @@ export module '@theia/plugin' {
          */
         export const onDidChangeTerminalState: Event<Terminal>;
 
+        /**
+         * Fires when shell integration activates or one of its properties changes in a terminal.
+         * @stubbed
+         */
+        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.
+         * @stubbed
+         */
+        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.
+         * @stubbed
+         */
+        export const onDidEndTerminalShellExecution: Event<TerminalShellExecutionEndEvent>;
+
         /**
          * Create new terminal with predefined options.
          * @param - terminal options.
@@ -6368,13 +6728,31 @@ export module '@theia/plugin' {
         badge: ViewBadge | undefined;
 
         /**
-         * Reveal an element. By default revealed element is selected.
+         * Reveals the given element in the tree view.
+         * If the tree view is not visible then the tree view is shown and element is revealed.
          *
+         * By default revealed element is selected.
          * In order to not to select, set the option `select` to `false`.
+         * In order to focus, set the option `focus` to `true`.
+         * In order to expand the revealed element, set the option `expand` to `true`. To expand recursively set `expand` to the number of levels to expand.
          *
-         * **NOTE:** {@link TreeDataProvider TreeDataProvider} is required to implement {@link TreeDataProvider.getParent getParent} method to access this API.
+         * * *NOTE:* In VS Code, you can expand only to 3 levels maximum. This is not the case in Theia, there are no limits to expansion level.
+         * * *NOTE:* The {@link TreeDataProvider} that the `TreeView` {@link window.createTreeView is registered with} with must implement {@link TreeDataProvider.getParent getParent} method to access this API.
          */
-        reveal(element: T, options?: { select?: boolean; focus?: boolean; expand?: boolean | number }): Thenable<void>;
+        reveal(element: T, options?: {
+            /**
+             * If true, then the element will be selected.
+             */
+            readonly select?: boolean;
+            /**
+             * If true, then the element will be focused.
+             */
+            readonly focus?: boolean;
+            /**
+             * If true, then the element will be expanded. If a number is passed, then up to that number of levels of children will be expanded
+             */
+            readonly expand?: boolean | number;
+        }): Thenable<void>;
     }
 
     /**
@@ -14084,6 +14462,11 @@ export module '@theia/plugin' {
          * Note: you cannot use this option with any other options that prompt the user like {@link createIfNone}.
          */
         silent?: boolean;
+
+        /**
+         * The account that you would like to get a session for. This is passed down to the Authentication Provider to be used for creating the correct session.
+         */
+        account?: AuthenticationSessionAccountInformation;
     }
 
     /**
@@ -14144,6 +14527,18 @@ export module '@theia/plugin' {
         readonly changed: readonly AuthenticationSession[] | undefined;
     }
 
+    /**
+     * The options passed in to the {@link AuthenticationProvider.getSessions} and
+     * {@link AuthenticationProvider.createSession} call.
+     */
+    export interface AuthenticationProviderSessionOptions {
+        /**
+         * The account that is being asked about. If this is passed in, the provider should
+         * attempt to return the sessions that are only related to this account.
+         */
+        account?: AuthenticationSessionAccountInformation;
+    }
+
     /**
      * A provider for performing authentication to a service.
      */
@@ -14158,9 +14553,10 @@ export module '@theia/plugin' {
          * Get a list of sessions.
          * @param scopes An optional list of scopes. If provided, the sessions returned should match
          * these permissions, otherwise all sessions should be returned.
+         * @param options Additional options for getting sessions.
          * @returns A promise that resolves to an array of authentication sessions.
          */
-        getSessions(scopes?: readonly string[]): Thenable<readonly AuthenticationSession[]>;
+        getSessions(scopes: readonly string[] | undefined, options: AuthenticationProviderSessionOptions): Thenable<AuthenticationSession[]>;
 
         /**
          * Prompts a user to login.
@@ -14173,9 +14569,10 @@ export module '@theia/plugin' {
          * then this should never be called if there is already an existing session matching these
          * scopes.
          * @param scopes A list of scopes, permissions, that the new session should be created with.
+         * @param options Additional options for creating a session.
          * @returns A promise that resolves to an authentication session.
          */
-        createSession(scopes: readonly string[]): Thenable<AuthenticationSession>;
+        createSession(scopes: readonly string[], options: AuthenticationProviderSessionOptions): Thenable<AuthenticationSession>;
 
         /**
          * Removes the session corresponding to session id.
@@ -14235,6 +14632,20 @@ export module '@theia/plugin' {
          */
         export function getSession(providerId: string, scopes: readonly string[], options?: AuthenticationGetSessionOptions): Thenable<AuthenticationSession | undefined>;
 
+        /**
+         * Get all accounts that the user is logged in to for the specified provider.
+         * Use this paired with {@link getSession} in order to get an authentication session for a specific account.
+         *
+         * Currently, there are only two authentication providers that are contributed from built in extensions
+         * to the editor that implement GitHub and Microsoft authentication: their providerId's are 'github' and 'microsoft'.
+         *
+         * Note: Getting accounts does not imply that your extension has access to that account or its authentication sessions. You can verify access to the account by calling {@link getSession}.
+         *
+         * @param providerId The id of the provider to use
+         * @returns A thenable that resolves to a readonly array of authentication accounts.
+         */
+        export function getAccounts(providerId: string): Thenable<readonly AuthenticationSessionAccountInformation[]>;
+
         /**
          * An {@link Event event} which fires when the authentication sessions of an authentication provider have
          * been added, removed, or changed.
@@ -16573,6 +16984,34 @@ export module '@theia/plugin' {
         error: string | MarkdownString | undefined;
     }
 
+    /**
+     * A stack frame found in the {@link TestMessage.stackTrace}.
+     */
+    export class TestMessageStackFrame {
+        /**
+         * The location of this stack frame. This should be provided as a URI if the
+         * location of the call frame can be accessed by the editor.
+         */
+        uri?: Uri;
+
+        /**
+         * Position of the stack frame within the file.
+         */
+        position?: Position;
+
+        /**
+         * The name of the stack frame, typically a method or function name.
+         */
+        label: string;
+
+        /**
+         * @param label The name of the stack frame
+         * @param file The file URI of the stack frame
+         * @param position The position of the stack frame within the file
+         */
+        constructor(label: string, uri?: Uri, position?: Position);
+    }
+
     /**
      * Message associated with the test state. Can be linked to a specific
      * source range -- useful for assertion failures, for example.
@@ -16629,6 +17068,11 @@ export module '@theia/plugin' {
          */
         contextValue?: string;
 
+        /**
+         * The stack trace associated with the message or failure.
+         */
+        stackTrace?: TestMessageStackFrame[];
+
         /**
          * Creates a new TestMessage that will present as a diff in the editor.
          * @param message Message to display to the user.

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

@@ -41,9 +41,13 @@ export module '@theia/plugin' {
          * @param extensionId An extension identifier.
          * @param includeDifferentExtensionHosts Include extensions from different extension host
          * @return An extension or `undefined`.
+         *
+         * *Note* In Theia, includeDifferentExtensionHosts will always be set to false, as we only support one host currently.
          */
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         export function getExtension<T = any>(extensionId: string, includeDifferentExtensionHosts: boolean): Extension<T> | undefined;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        export function getExtension<T = any>(extensionId: string, includeDifferentExtensionHosts: true): Extension<T | undefined> | undefined;
 
         /**
          * All extensions across all extension hosts.

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

@@ -1,329 +0,0 @@
-// *****************************************************************************
-// 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>;
-    }
-}