@codingame/monaco-vscode-api 20.1.0 → 20.2.0

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

@@ -23,6 +23,11 @@ import type { ICurrentPartialCommand } from "@codingame/monaco-vscode-88141f48-1
 import type { IMenu } from "../../../../platform/actions/common/actions.js";
 import type { Barrier } from "../../../../base/common/async.js";
 import type { IProgressState } from "@xterm/addon-progress";
+/**
+ * A terminal contribution that gets created whenever a terminal is created. A contribution has
+ * access to the process manager through the constructor and provides a method for when xterm.js has
+ * been initialized.
+ */
 export interface ITerminalContribution extends IDisposable {
     layout?(xterm: IXtermTerminal & {
         raw: RawXtermTerminal;
@@ -108,19 +113,65 @@ export interface IDetachedXTermOptions {
     readonly?: boolean;
     processInfo: ITerminalProcessInfo;
 }
+/**
+ * A generic interface implemented in both the {@link ITerminalInstance} (an
+ * interface used for terminals attached to the terminal panel or editor) and
+ * {@link IDetachedTerminalInstance} (a terminal used elsewhere in VS Code UI).
+ */
 export interface IBaseTerminalInstance {
     readonly capabilities: ITerminalCapabilityStore;
+    /**
+     * DOM element the terminal is mounted in.
+     */
     readonly domElement?: HTMLElement;
+    /**
+     * Current selection in the terminal.
+     */
     readonly selection: string | undefined;
+    /**
+     * Check if anything is selected in terminal.
+     */
     hasSelection(): boolean;
+    /**
+     * Clear current selection.
+     */
     clearSelection(): void;
+    /**
+     * Focuses the terminal instance if it's able to (the xterm.js instance must exist).
+     *
+     * @param force Force focus even if there is a selection.
+     */
     focus(force?: boolean): void;
+    /**
+     * Force the scroll bar to be visible until {@link resetScrollbarVisibility} is called.
+     */
     forceScrollbarVisibility(): void;
+    /**
+     * Resets the scroll bar to only be visible when needed, this does nothing unless
+     * {@link forceScrollbarVisibility} was called.
+     */
     resetScrollbarVisibility(): void;
+    /**
+     * Gets a terminal contribution by its ID.
+     */
     getContribution<T extends ITerminalContribution>(id: string): T | null;
 }
+/**
+ * A {@link ITerminalInstance}-like object that emulates a subset of
+ * capabilities. This instance is returned from {@link ITerminalService.createDetachedTerminal}
+ * to represent terminals that appear in other parts of the VS Code UI outside
+ * of the "Terminal" view or editors.
+ */
 export interface IDetachedTerminalInstance extends IDisposable, IBaseTerminalInstance {
     readonly xterm: IDetachedXtermTerminal;
+    /**
+     * Attached the terminal to the given element. This should be preferred over
+     * calling {@link IXtermTerminal.attachToElement} so that extra DOM elements
+     * for contributions are initialized.
+     *
+     * @param container Container the terminal will be rendered in
+     * @param options Additional options for mounting the terminal in an element
+     */
     attachToElement(container: HTMLElement, options?: Partial<IXtermAttachToElementOptions>): void;
 }
 export declare const isDetachedTerminalInstance: (t: ITerminalInstance | IDetachedTerminalInstance) => t is IDetachedTerminalInstance;
@@ -155,16 +206,38 @@ export type ITerminalLocationOptions = TerminalLocation | TerminalEditorLocation
     splitActiveTerminal: boolean;
 };
 export interface ICreateTerminalOptions {
+    /**
+     * The shell launch config or profile to launch with, when not specified the default terminal
+     * profile will be used.
+     */
     config?: IShellLaunchConfig | ITerminalProfile | IExtensionTerminalProfile;
+    /**
+     * The current working directory to start with, this will override IShellLaunchConfig.cwd if
+     * specified.
+     */
     cwd?: string | URI;
+    /**
+     * The terminal's resource, passed when the terminal has moved windows.
+     */
     resource?: URI;
+    /**
+     * The terminal's location (editor or panel), it's terminal parent (split to the right), or editor group
+     */
     location?: ITerminalLocationOptions;
+    /**
+     * This terminal will not wait for contributed profiles to resolve which means it will proceed
+     * when the workbench is not yet loaded.
+     */
     skipContributedProfileCheck?: boolean;
 }
 export interface TerminalEditorLocation {
     viewColumn: GroupIdentifier | SIDE_GROUP_TYPE | ACTIVE_GROUP_TYPE | AUX_WINDOW_GROUP_TYPE;
     preserveFocus?: boolean;
 }
+/**
+ * An interface that indicates the implementer hosts terminal instances, exposing a common set of
+ * properties and events.
+ */
 export interface ITerminalInstanceHost {
     readonly activeInstance: ITerminalInstance | undefined;
     readonly instances: readonly ITerminalInstance[];
@@ -174,27 +247,64 @@ export interface ITerminalInstanceHost {
     readonly onDidChangeInstances: Event<void>;
     readonly onDidChangeInstanceCapability: Event<ITerminalInstance>;
     setActiveInstance(instance: ITerminalInstance): void;
+    /**
+     * Reveal and focus the instance, regardless of its location.
+     */
     focusInstance(instance: ITerminalInstance): void;
+    /**
+     * Reveal and focus the active instance, regardless of its location.
+     */
     focusActiveInstance(): Promise<void>;
+    /**
+     * Gets an instance from a resource if it exists. This MUST be used instead of getInstanceFromId
+     * when you only know about a terminal's URI. (a URI's instance ID may not be this window's instance ID)
+     */
     getInstanceFromResource(resource: URI | undefined): ITerminalInstance | undefined;
 }
+/**
+ * Similar to xterm.js' ILinkProvider but using promises and hides xterm.js internals (like buffer
+ * positions, decorations, etc.) from the rest of vscode. This is the interface to use for
+ * workbench integrations.
+ */
 export interface ITerminalExternalLinkProvider {
     provideLinks(instance: ITerminalInstance, line: string): Promise<ITerminalLink[] | undefined>;
 }
 export interface ITerminalLink {
+    /** The startIndex of the link in the line. */
     startIndex: number;
+    /** The length of the link in the line. */
     length: number;
+    /** The descriptive label for what the link does when activated. */
     label?: string;
+    /**
+     * Activates the link.
+     * @param text The text of the link.
+     */
     activate(text: string): void;
 }
 export interface ISearchOptions {
+    /** Whether the find should be done as a regex. */
     regex?: boolean;
+    /** Whether only whole words should match. */
     wholeWord?: boolean;
+    /** Whether find should pay attention to case. */
     caseSensitive?: boolean;
+    /** Whether the search should start at the current search position (not the next row). */
     incremental?: boolean;
 }
 export interface ITerminalInstance extends IBaseTerminalInstance {
+    /**
+     * The ID of the terminal instance, this is an arbitrary number only used to uniquely identify
+     * terminal instances within a window.
+     */
     readonly instanceId: number;
+    /**
+     * A unique URI for this terminal instance with the following encoding:
+     * path: /<workspace ID>/<instance ID>
+     * fragment: Title
+     * Note that when dragging terminals across windows, this will retain the original workspace ID /instance ID
+     * from the other window.
+     */
     readonly resource: URI;
     readonly cols: number;
     readonly rows: number;
@@ -218,24 +328,67 @@ export interface ITerminalInstance extends IBaseTerminalInstance {
     readonly shellIntegrationInjectionFailureReason: ShellIntegrationInjectionFailureReason | undefined;
     readonly injectedArgs: string[] | undefined;
     readonly extEnvironmentVariableCollection: IMergedEnvironmentVariableCollection | undefined;
+    /**
+     * The underlying disposable store, allowing objects who share the same lifecycle as the
+     * terminal instance but are created externally to be managed by the instance.
+     */
     readonly store: DisposableStore;
     readonly statusList: ITerminalStatusList;
+    /**
+     * The process ID of the shell process, this is undefined when there is no process associated
+     * with this terminal.
+     */
     processId: number | undefined;
+    /**
+     * The position of the terminal.
+     */
     target: TerminalLocation | undefined;
     targetRef: IReference<TerminalLocation | undefined>;
+    /**
+     * The id of a persistent process. This is defined if this is a terminal created by a pty host
+     * that supports reconnection.
+     */
     readonly persistentProcessId: number | undefined;
+    /**
+     * Whether the process should be persisted across reloads.
+     */
     readonly shouldPersist: boolean;
     readonly isDisposed: boolean;
+    /**
+     * Whether the terminal's pty is hosted on a remote.
+     */
     readonly isRemote: boolean;
+    /**
+     * The remote authority of the terminal's pty.
+     */
     readonly remoteAuthority: string | undefined;
+    /**
+     * Whether an element within this terminal is focused.
+     */
     readonly hasFocus: boolean;
+    /**
+     * The ID of the session that this terminal is connected to
+     */
     readonly sessionId: string;
+    /**
+     * Get or set the behavior of the terminal when it closes. This was indented only to be called
+     * after reconnecting to a terminal.
+     */
     waitOnExit: WaitOnExitValue | undefined;
+    /**
+     * An event that fires when the terminal instance's title changes.
+     */
     onTitleChanged: Event<ITerminalInstance>;
+    /**
+     * An event that fires when the terminal instance's icon changes.
+     */
     onIconChanged: Event<{
         instance: ITerminalInstance;
         userInitiated: boolean;
     }>;
+    /**
+     * An event that fires when the terminal instance is disposed.
+     */
     onDisposed: Event<ITerminalInstance>;
     onProcessIdReady: Event<ITerminalInstance>;
     onProcessReplayComplete: Event<void>;
@@ -253,81 +406,323 @@ export interface ITerminalInstance extends IBaseTerminalInstance {
     onDidSendText: Event<string>;
     onDidChangeShellType: Event<TerminalShellType>;
     onDidChangeVisibility: Event<boolean>;
+    /**
+     * An event that fires when a terminal is dropped on this instance via drag and drop.
+     */
     onRequestAddInstanceToGroup: Event<IRequestAddInstanceToGroupEvent>;
+    /**
+     * Attach a listener to the raw data stream coming from the pty, including ANSI escape
+     * sequences.
+     */
     onData: Event<string>;
     onWillData: Event<string>;
+    /**
+     * Attach a listener to the binary data stream coming from xterm and going to pty
+     */
     onBinary: Event<string>;
+    /**
+     * Attach a listener to listen for new lines added to this terminal instance.
+     *
+     * @param listener The listener function which takes new line strings added to the terminal,
+     * excluding ANSI escape sequences. The line event will fire when an LF character is added to
+     * the terminal (ie. the line is not wrapped). Note that this means that the line data will
+     * not fire for the last line, until either the line is ended with a LF character of the process
+     * is exited. The lineData string will contain the fully wrapped line, not containing any LF/CR
+     * characters.
+     */
     onLineData: Event<string>;
+    /**
+     * Attach a listener that fires when the terminal's pty process exits. The number in the event
+     * is the processes' exit code, an exit code of undefined means the process was killed as a result of
+     * the ITerminalInstance being disposed.
+     */
     onExit: Event<number | ITerminalLaunchError | undefined>;
+    /**
+     * The exit code or undefined when the terminal process hasn't yet exited or
+     * the process exit code could not be determined. Use {@link exitReason} to see
+     * why the process has exited.
+     */
     readonly exitCode: number | undefined;
+    /**
+     * The reason the terminal process exited, this will be undefined if the process is still
+     * running.
+     */
     readonly exitReason: TerminalExitReason | undefined;
+    /**
+     * The xterm.js instance for this terminal.
+     */
     readonly xterm?: XtermTerminal;
+    /**
+     * Resolves when the xterm.js instance for this terminal is ready.
+     */
     readonly xtermReadyPromise: Promise<XtermTerminal | undefined>;
+    /**
+     * Returns an array of data events that have fired within the first 10 seconds. If this is
+     * called 10 seconds after the terminal has existed the result will be undefined. This is useful
+     * when objects that depend on the data events have delayed initialization, like extension
+     * hosts.
+     */
     readonly initialDataEvents: string[] | undefined;
+    /** A promise that resolves when the terminal's pty/process have been created. */
     readonly processReady: Promise<void>;
+    /** Whether the terminal's process has child processes (ie. is dirty/busy). */
     readonly hasChildProcesses: boolean;
+    /**
+     * The title of the terminal. This is either title or the process currently running or an
+     * explicit name given to the terminal instance through the extension API.
+     */
     readonly title: string;
+    /**
+     * How the current title was set.
+     */
     readonly titleSource: TitleEventSource;
+    /**
+     * The shell type of the terminal.
+     */
     readonly shellType: TerminalShellType | undefined;
+    /**
+     * The focus state of the terminal before exiting.
+     */
     readonly hadFocusOnExit: boolean;
+    /**
+     * False when the title is set by an API or the user. We check this to make sure we
+     * do not override the title when the process title changes in the terminal.
+     */
     isTitleSetByProcess: boolean;
+    /**
+     * The shell launch config used to launch the shell.
+     */
     readonly shellLaunchConfig: IShellLaunchConfig;
+    /**
+     * Whether to disable layout for the terminal. This is useful when the size of the terminal is
+     * being manipulating (e.g. adding a split pane) and we want the terminal to ignore particular
+     * resize events.
+     */
     disableLayout: boolean;
+    /**
+     * The description of the terminal, this is typically displayed next to {@link title}.
+     */
     description: string | undefined;
+    /**
+     * The remote-aware $HOME directory (or Windows equivalent) of the terminal.
+     */
     userHome: string | undefined;
+    /**
+     * The nonce used to verify commands coming from shell integration.
+     */
     shellIntegrationNonce: string;
+    /**
+     * Registers and returns a marker
+     * @param the y offset from the cursor
+     */
     registerMarker(offset?: number): IMarker | undefined;
+    /**
+     * Adds a marker to the buffer, mapping it to an ID if provided.
+     */
     addBufferMarker(properties: IMarkProperties): void;
+    /**
+     *
+     * @param startMarkId The ID for the start marker
+     * @param endMarkId The ID for the end marker
+     * @param highlight Whether the buffer from startMarker to endMarker
+     * should be highlighted
+     */
     scrollToMark(startMarkId: string, endMarkId?: string, highlight?: boolean): void;
+    /**
+     * Dispose the terminal instance, removing it from the panel/service and freeing up resources.
+     *
+     * @param reason The reason why the terminal is being disposed
+     */
     dispose(reason?: TerminalExitReason): void;
+    /**
+     * Informs the process that the terminal is now detached and
+     * then disposes the terminal.
+     *
+     * @param reason The reason why the terminal is being disposed
+     */
     detachProcessAndDispose(reason: TerminalExitReason): Promise<void>;
+    /**
+     * When the panel is hidden or a terminal in the editor area becomes inactive, reset the focus context key
+     * to avoid issues like #147180.
+     */
     resetFocusContextKey(): void;
+    /**
+     * Focuses the terminal instance when it's ready (the xterm.js instance much exist). This is the
+     * best focus call when the terminal is being shown for example.
+     * when the terminal is being shown.
+     *
+     * @param force Force focus even if there is a selection.
+     */
     focusWhenReady(force?: boolean): Promise<void>;
+    /**
+     * Send text to the terminal instance. The text is written to the stdin of the underlying pty
+     * process (shell) of the terminal instance.
+     *
+     * @param text The text to send.
+     * @param shouldExecute Indicates that the text being sent should be executed rather than just inserted in the terminal.
+     * The character(s) added are \n or \r\n, depending on the platform. This defaults to `true`.
+     * @param bracketedPasteMode Whether to wrap the text in the bracketed paste mode sequence when
+     * it's enabled. When true, the shell will treat the text as if it were pasted into the shell,
+     * this may for example select the text and it will also ensure that the text will not be
+     * interpreted as a shell keybinding.
+     */
     sendText(text: string, shouldExecute: boolean, bracketedPasteMode?: boolean): Promise<void>;
+    /**
+     * Sends a signal to the terminal instance's process.
+     *
+     * @param signal The signal to send (e.g., 'SIGTERM', 'SIGINT', 'SIGKILL').
+     */
     sendSignal(signal: string): Promise<void>;
+    /**
+     * Sends a path to the terminal instance, preparing it as needed based on the detected shell
+     * running within the terminal. The text is written to the stdin of the underlying pty process
+     * (shell) of the terminal instance.
+     *
+     * @param originalPath The path to send.
+     * @param shouldExecute Indicates that the text being sent should be executed rather than just inserted in the terminal.
+     * The character(s) added are \n or \r\n, depending on the platform. This defaults to `true`.
+     */
     sendPath(originalPath: string | URI, shouldExecute: boolean): Promise<void>;
     runCommand(command: string, shouldExecute?: boolean): Promise<void>;
+    /**
+     * Takes a path and returns the properly escaped path to send to a given shell. On Windows, this
+     * includes trying to prepare the path for WSL if needed.
+     *
+     * @param originalPath The path to be escaped and formatted.
+     */
     preparePathForShell(originalPath: string): Promise<string>;
-    scrollDownLine(): void;
-    scrollDownPage(): void;
-    scrollToBottom(): void;
-    scrollUpLine(): void;
-    scrollUpPage(): void;
-    scrollToTop(): void;
+    /** Scroll the terminal buffer down 1 line. */ scrollDownLine(): void;
+    /** Scroll the terminal buffer down 1 page. */ scrollDownPage(): void;
+    /** Scroll the terminal buffer to the bottom. */ scrollToBottom(): void;
+    /** Scroll the terminal buffer up 1 line. */ scrollUpLine(): void;
+    /** Scroll the terminal buffer up 1 page. */ scrollUpPage(): void;
+    /** Scroll the terminal buffer to the top. */ scrollToTop(): void;
+    /**
+     * Clears the terminal buffer, leaving only the prompt line and moving it to the top of the
+     * viewport.
+     */
     clearBuffer(): void;
+    /**
+     * Attaches the terminal instance to an element on the DOM, before this is called the terminal
+     * instance process may run in the background but cannot be displayed on the UI.
+     *
+     * @param container The element to attach the terminal instance to.
+     */
     attachToElement(container: HTMLElement): void;
+    /**
+     * Detaches the terminal instance from the terminal editor DOM element.
+     */
     detachFromElement(): void;
+    /**
+     * Layout the terminal instance.
+     *
+     * @param dimension The dimensions of the container.
+     */
     layout(dimension: {
         width: number;
         height: number;
     }): void;
+    /**
+     * Sets whether the terminal instance's element is visible in the DOM.
+     *
+     * @param visible Whether the element is visible.
+     */
     setVisible(visible: boolean): void;
+    /**
+     * Immediately kills the terminal's current pty process and launches a new one to replace it.
+     *
+     * @param shell The new launch configuration.
+     */
     reuseTerminal(shell: IShellLaunchConfig): Promise<void>;
+    /**
+     * Relaunches the terminal, killing it and reusing the launch config used initially. Any
+     * environment variable changes will be recalculated when this happens.
+     */
     relaunch(): void;
+    /**
+     * Sets the terminal instance's dimensions to the values provided via the onDidOverrideDimensions event,
+     * which allows overriding the regular dimensions (fit to the size of the panel).
+     */
     setOverrideDimensions(dimensions: ITerminalDimensions): void;
+    /**
+     * Sets the terminal instance's dimensions to the values provided via quick input.
+     */
     setFixedDimensions(): Promise<void>;
+    /**
+     * Toggles terminal line wrapping.
+     */
     toggleSizeToContentWidth(): Promise<void>;
+    /**
+     * Gets the initial current working directory, fetching it from the backend if required.
+     */
     getInitialCwd(): Promise<string>;
+    /**
+     * Gets the current working directory from cwd detection capabilities if available, otherwise
+     * from the backend. This will return the initial cwd if cwd detection is not available (ie.
+     * on Windows when shell integration is disabled).
+     */
     getSpeculativeCwd(): Promise<string>;
+    /**
+     * Gets the cwd as a URI that has been validated to exist.
+     */
     getCwdResource(): Promise<URI | undefined>;
+    /**
+     * Sets the title of the terminal to the provided string. If no title is provided, it will reset
+     * to the terminal's title if it was not explicitly set by the user or API.
+     * @param title The new title.
+     */
     rename(title?: string): Promise<void>;
+    /**
+     * Sets or triggers a quick pick to change the icon of this terminal.
+     */
     changeIcon(icon?: TerminalIcon): Promise<TerminalIcon | undefined>;
+    /**
+     * Sets or triggers a quick pick to change the color of the associated terminal tab icon.
+     */
     changeColor(color?: string, skipQuickPick?: boolean): Promise<string | undefined>;
+    /**
+     * Attempts to detect and kill the process listening on specified port.
+     * If successful, places commandToRun on the command line
+     */
     freePortKillProcess(port: string, commandToRun: string): Promise<void>;
+    /**
+     * Update the parent context key service to use for this terminal instance.
+     */
     setParentContextKeyService(parentContextKeyService: IContextKeyService): void;
+    /**
+     * Handles a mouse event for the terminal, this may happen on an anscestor of the terminal
+     * instance's element.
+     * @param event The mouse event.
+     * @param contextMenu The context menu to show if needed.
+     * @returns Whether the context menu should be suppressed.
+     */
     handleMouseEvent(event: MouseEvent, contextMenu: IMenu): Promise<{
         cancelContextMenu: boolean;
     } | void>;
+    /**
+     * Pause input events until the provided barrier is resolved.
+     * @param barrier The barrier to wait for until input events can continue.
+     */
     pauseInputEvents(barrier: Barrier): void;
 }
 export declare enum XtermTerminalConstants {
     SearchHighlightLimit = 20000
 }
 export interface IXtermAttachToElementOptions {
+    /**
+     * Whether GPU rendering should be enabled for this element, defaults to true.
+     */
     enableGpu: boolean;
 }
 export interface IXtermTerminal extends IDisposable {
+    /**
+     * An object that tracks when commands are run and enables navigating and selecting between
+     * them.
+     */
     readonly markTracker: IMarkTracker;
+    /**
+     * Reports the status of shell integration and fires events relating to it.
+     */
     readonly shellIntegration: IShellIntegration;
     readonly decorationAddon: IDecorationAddon;
     readonly onDidChangeSelection: Event<void>;
@@ -342,48 +737,148 @@ export interface IXtermTerminal extends IDisposable {
     readonly onDidRequestCopyAsHtml: Event<{
         command: ITerminalCommand;
     }>;
+    /**
+     * Event fired when focus enters (fires with true) or leaves (false) the terminal.
+     */
     readonly onDidChangeFocus: Event<boolean>;
+    /**
+     * Gets a view of the current texture atlas used by the renderers.
+     */
     readonly textureAtlas: Promise<ImageBitmap> | undefined;
+    /**
+     * Whether the `disableStdin` option in xterm.js is set.
+     */
     readonly isStdinDisabled: boolean;
+    /**
+     * Whether the terminal is currently focused.
+     */
     readonly isFocused: boolean;
+    /**
+     * Whether a canvas-based renderer is being used.
+     */
     readonly isGpuAccelerated: boolean;
+    /**
+     * The last `onData` input event fired by {@link RawXtermTerminal.onData}.
+     */
     readonly lastInputEvent: string | undefined;
+    /**
+     * Attached the terminal to the given element
+     * @param container Container the terminal will be rendered in
+     * @param options Additional options for mounting the terminal in an element
+     */
     attachToElement(container: HTMLElement, options?: Partial<IXtermAttachToElementOptions>): void;
     findResult?: {
         resultIndex: number;
         resultCount: number;
     };
+    /**
+     * Find the next instance of the term
+    */
     findNext(term: string, searchOptions: ISearchOptions): Promise<boolean>;
+    /**
+     * Find the previous instance of the term
+     */
     findPrevious(term: string, searchOptions: ISearchOptions): Promise<boolean>;
+    /**
+     * Forces the terminal to redraw its viewport.
+     */
     forceRedraw(): void;
+    /**
+     * Gets the font metrics of this xterm.js instance.
+     */
     getFont(): ITerminalFont;
+    /**
+     * Gets whether there's any terminal selection.
+     */
     hasSelection(): boolean;
+    /**
+     * Clears any terminal selection.
+     */
     clearSelection(): void;
+    /**
+     * Selects all terminal contents/
+     */
     selectAll(): void;
+    /**
+     * Selects the content between the two markers by their VS Code OSC `SetMarker`
+     * ID. It's a no-op if either of the two markers are not found.
+     *
+     * @param fromMarkerId Start marker ID
+     * @param toMarkerId End marker ID
+     * @param scrollIntoView Whether the terminal should scroll to the start of
+     * the range, defaults tof alse
+     */
     selectMarkedRange(fromMarkerId: string, toMarkerId: string, scrollIntoView?: boolean): void;
+    /**
+     * Copies the terminal selection.
+     * @param copyAsHtml Whether to copy selection as HTML, defaults to false.
+     */
     copySelection(copyAsHtml?: boolean, command?: ITerminalCommand): void;
+    /**
+     * Focuses the terminal. Warning: {@link ITerminalInstance.focus} should be
+     * preferred when dealing with terminal instances in order to get
+     * accessibility triggers.
+     */
     focus(): void;
-    scrollDownLine(): void;
-    scrollDownPage(): void;
-    scrollToBottom(): void;
-    scrollUpLine(): void;
-    scrollUpPage(): void;
-    scrollToTop(): void;
-    scrollToLine(line: number, position?: ScrollPosition): void;
+    /** Scroll the terminal buffer down 1 line.   */ scrollDownLine(): void;
+    /** Scroll the terminal buffer down 1 page.   */ scrollDownPage(): void;
+    /** Scroll the terminal buffer to the bottom. */ scrollToBottom(): void;
+    /** Scroll the terminal buffer up 1 line.     */ scrollUpLine(): void;
+    /** Scroll the terminal buffer up 1 page.     */ scrollUpPage(): void;
+    /** Scroll the terminal buffer to the top.    */ scrollToTop(): void;
+    /** Scroll the terminal buffer to a set line  */ scrollToLine(line: number, position?: ScrollPosition): void;
+    /**
+     * Clears the terminal buffer, leaving only the prompt line and moving it to the top of the
+     * viewport.
+     */
     clearBuffer(): void;
+    /**
+     * Clears the search result decorations
+     */
     clearSearchDecorations(): void;
+    /**
+     * Clears the active search result decorations
+     */
     clearActiveSearchDecoration(): void;
+    /**
+     * Returns a reverse iterator of buffer lines as strings
+     */
     getBufferReverseIterator(): IterableIterator<string>;
+    /**
+     * Gets the contents of the buffer from a start marker (or line 0) to the end marker (or the
+     * last line).
+     */
     getContentsAsText(startMarker?: IXtermMarker, endMarker?: IXtermMarker): string;
+    /**
+     * Gets the buffer contents as HTML.
+     */
     getContentsAsHtml(): Promise<string>;
+    /**
+     * Refreshes the terminal after it has been moved.
+     */
     refresh(): void;
     getXtermTheme(theme?: IColorTheme): ITheme;
 }
 export interface IDetachedXtermTerminal extends IXtermTerminal {
+    /**
+     * Writes data to the terminal.
+     * @param data data to write
+     * @param callback Optional callback that fires when the data was processed
+     * by the parser.
+     */
     write(data: string | Uint8Array, callback?: () => void): void;
+    /**
+     * Resizes the terminal.
+     */
     resize(columns: number, rows: number): void;
 }
 export interface IInternalXtermTerminal {
+    /**
+     * Writes text directly to the terminal, bypassing the process.
+     *
+     * **WARNING:** This should never be used outside of the terminal component and only for
+     * developer purposed inside the terminal component.
+     */
     _writeText(data: string): void;
 }
 export interface IXtermColorProvider {