/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
import { Event } from "../../../base/common/event.mjs";
import { IProcessEnvironment, OperatingSystem } from "../../../base/common/platform.mjs";
import { URI, UriComponents } from "../../../base/common/uri.mjs";
import { IPtyHostProcessReplayEvent, ISerializedCommandDetectionCapability, ITerminalCapabilityStore } from "./capabilities/capabilities.mjs";
import { IGetTerminalLayoutInfoArgs, IProcessDetails, ISetTerminalLayoutInfoArgs } from "./terminalProcess.mjs";
import { ThemeIcon } from "../../theme/common/themeService.mjs";
import { ISerializableEnvironmentVariableCollections } from "./environmentVariable.mjs";
import { ITerminalCommandSelector } from "./xterm/terminalQuickFix.mjs";
export declare const enum TerminalSettingPrefix {
    Shell = "terminal.integrated.shell.",
    ShellArgs = "terminal.integrated.shellArgs.",
    DefaultProfile = "terminal.integrated.defaultProfile.",
    Profiles = "terminal.integrated.profiles."
}
export declare const enum TerminalSettingId {
    ShellLinux = "terminal.integrated.shell.linux",
    ShellMacOs = "terminal.integrated.shell.osx",
    ShellWindows = "terminal.integrated.shell.windows",
    SendKeybindingsToShell = "terminal.integrated.sendKeybindingsToShell",
    AutomationShellLinux = "terminal.integrated.automationShell.linux",
    AutomationShellMacOs = "terminal.integrated.automationShell.osx",
    AutomationShellWindows = "terminal.integrated.automationShell.windows",
    AutomationProfileLinux = "terminal.integrated.automationProfile.linux",
    AutomationProfileMacOs = "terminal.integrated.automationProfile.osx",
    AutomationProfileWindows = "terminal.integrated.automationProfile.windows",
    ShellArgsLinux = "terminal.integrated.shellArgs.linux",
    ShellArgsMacOs = "terminal.integrated.shellArgs.osx",
    ShellArgsWindows = "terminal.integrated.shellArgs.windows",
    ProfilesWindows = "terminal.integrated.profiles.windows",
    ProfilesMacOs = "terminal.integrated.profiles.osx",
    ProfilesLinux = "terminal.integrated.profiles.linux",
    DefaultProfileLinux = "terminal.integrated.defaultProfile.linux",
    DefaultProfileMacOs = "terminal.integrated.defaultProfile.osx",
    DefaultProfileWindows = "terminal.integrated.defaultProfile.windows",
    UseWslProfiles = "terminal.integrated.useWslProfiles",
    TabsDefaultColor = "terminal.integrated.tabs.defaultColor",
    TabsDefaultIcon = "terminal.integrated.tabs.defaultIcon",
    TabsEnabled = "terminal.integrated.tabs.enabled",
    TabsEnableAnimation = "terminal.integrated.tabs.enableAnimation",
    TabsHideCondition = "terminal.integrated.tabs.hideCondition",
    TabsShowActiveTerminal = "terminal.integrated.tabs.showActiveTerminal",
    TabsShowActions = "terminal.integrated.tabs.showActions",
    TabsLocation = "terminal.integrated.tabs.location",
    TabsFocusMode = "terminal.integrated.tabs.focusMode",
    MacOptionIsMeta = "terminal.integrated.macOptionIsMeta",
    MacOptionClickForcesSelection = "terminal.integrated.macOptionClickForcesSelection",
    AltClickMovesCursor = "terminal.integrated.altClickMovesCursor",
    CopyOnSelection = "terminal.integrated.copyOnSelection",
    EnableMultiLinePasteWarning = "terminal.integrated.enableMultiLinePasteWarning",
    DrawBoldTextInBrightColors = "terminal.integrated.drawBoldTextInBrightColors",
    FontFamily = "terminal.integrated.fontFamily",
    FontSize = "terminal.integrated.fontSize",
    LetterSpacing = "terminal.integrated.letterSpacing",
    LineHeight = "terminal.integrated.lineHeight",
    MinimumContrastRatio = "terminal.integrated.minimumContrastRatio",
    FastScrollSensitivity = "terminal.integrated.fastScrollSensitivity",
    MouseWheelScrollSensitivity = "terminal.integrated.mouseWheelScrollSensitivity",
    BellDuration = "terminal.integrated.bellDuration",
    FontWeight = "terminal.integrated.fontWeight",
    FontWeightBold = "terminal.integrated.fontWeightBold",
    CursorBlinking = "terminal.integrated.cursorBlinking",
    CursorStyle = "terminal.integrated.cursorStyle",
    CursorWidth = "terminal.integrated.cursorWidth",
    Scrollback = "terminal.integrated.scrollback",
    DetectLocale = "terminal.integrated.detectLocale",
    DefaultLocation = "terminal.integrated.defaultLocation",
    GpuAcceleration = "terminal.integrated.gpuAcceleration",
    TerminalTitleSeparator = "terminal.integrated.tabs.separator",
    TerminalTitle = "terminal.integrated.tabs.title",
    TerminalDescription = "terminal.integrated.tabs.description",
    RightClickBehavior = "terminal.integrated.rightClickBehavior",
    Cwd = "terminal.integrated.cwd",
    ConfirmOnExit = "terminal.integrated.confirmOnExit",
    ConfirmOnKill = "terminal.integrated.confirmOnKill",
    EnableBell = "terminal.integrated.enableBell",
    CommandsToSkipShell = "terminal.integrated.commandsToSkipShell",
    AllowChords = "terminal.integrated.allowChords",
    AllowMnemonics = "terminal.integrated.allowMnemonics",
    EnvMacOs = "terminal.integrated.env.osx",
    EnvLinux = "terminal.integrated.env.linux",
    EnvWindows = "terminal.integrated.env.windows",
    EnvironmentChangesIndicator = "terminal.integrated.environmentChangesIndicator",
    EnvironmentChangesRelaunch = "terminal.integrated.environmentChangesRelaunch",
    ShowExitAlert = "terminal.integrated.showExitAlert",
    SplitCwd = "terminal.integrated.splitCwd",
    WindowsEnableConpty = "terminal.integrated.windowsEnableConpty",
    WordSeparators = "terminal.integrated.wordSeparators",
    EnableFileLinks = "terminal.integrated.enableFileLinks",
    UnicodeVersion = "terminal.integrated.unicodeVersion",
    LocalEchoLatencyThreshold = "terminal.integrated.localEchoLatencyThreshold",
    LocalEchoEnabled = "terminal.integrated.localEchoEnabled",
    LocalEchoExcludePrograms = "terminal.integrated.localEchoExcludePrograms",
    LocalEchoStyle = "terminal.integrated.localEchoStyle",
    EnablePersistentSessions = "terminal.integrated.enablePersistentSessions",
    PersistentSessionReviveProcess = "terminal.integrated.persistentSessionReviveProcess",
    CustomGlyphs = "terminal.integrated.customGlyphs",
    PersistentSessionScrollback = "terminal.integrated.persistentSessionScrollback",
    InheritEnv = "terminal.integrated.inheritEnv",
    ShowLinkHover = "terminal.integrated.showLinkHover",
    IgnoreProcessNames = "terminal.integrated.ignoreProcessNames",
    AutoReplies = "terminal.integrated.autoReplies",
    ShellIntegrationEnabled = "terminal.integrated.shellIntegration.enabled",
    ShellIntegrationShowWelcome = "terminal.integrated.shellIntegration.showWelcome",
    ShellIntegrationDecorationsEnabled = "terminal.integrated.shellIntegration.decorationsEnabled",
    ShellIntegrationCommandHistory = "terminal.integrated.shellIntegration.history",
    SmoothScrolling = "terminal.integrated.smoothScrolling"
}
export declare const enum TerminalLogConstants {
    FileName = "ptyhost"
}
export declare const enum PosixShellType {
    PowerShell = "pwsh",
    Bash = "bash",
    Fish = "fish",
    Sh = "sh",
    Csh = "csh",
    Ksh = "ksh",
    Zsh = "zsh"
}
export declare const enum WindowsShellType {
    CommandPrompt = "cmd",
    PowerShell = "pwsh",
    Wsl = "wsl",
    GitBash = "gitbash"
}
export type TerminalShellType = PosixShellType | WindowsShellType | undefined;
export interface IRawTerminalInstanceLayoutInfo<T> {
    relativeSize: number;
    terminal: T;
}
export type ITerminalInstanceLayoutInfoById = IRawTerminalInstanceLayoutInfo<number>;
export type ITerminalInstanceLayoutInfo = IRawTerminalInstanceLayoutInfo<IPtyHostAttachTarget>;
export interface IRawTerminalTabLayoutInfo<T> {
    isActive: boolean;
    activePersistentProcessId: number | undefined;
    terminals: IRawTerminalInstanceLayoutInfo<T>[];
}
export type ITerminalTabLayoutInfoById = IRawTerminalTabLayoutInfo<number>;
export interface IRawTerminalsLayoutInfo<T> {
    tabs: IRawTerminalTabLayoutInfo<T>[];
}
export interface IPtyHostAttachTarget {
    id: number;
    pid: number;
    title: string;
    titleSource: TitleEventSource;
    cwd: string;
    workspaceId: string;
    workspaceName: string;
    isOrphan: boolean;
    icon: TerminalIcon | undefined;
    fixedDimensions: IFixedTerminalDimensions | undefined;
    environmentVariableCollections: ISerializableEnvironmentVariableCollections | undefined;
    reconnectionProperties?: IReconnectionProperties;
    waitOnExit?: WaitOnExitValue;
    hideFromUser?: boolean;
    isFeatureTerminal?: boolean;
    type?: TerminalType;
    hasChildProcesses: boolean;
}
export interface IReconnectionProperties {
    ownerId: string;
    data?: unknown;
}
export type TerminalType = 'Task' | 'Local' | undefined;
export declare enum TitleEventSource {
    /** From the API or the rename command that overrides any other type */
    Api = 0,
    /** From the process name property*/
    Process = 1,
    /** From the VT sequence */
    Sequence = 2,
    /** Config changed */
    Config = 3
}
export type ITerminalsLayoutInfo = IRawTerminalsLayoutInfo<IPtyHostAttachTarget | null>;
export type ITerminalsLayoutInfoById = IRawTerminalsLayoutInfo<number>;
export declare enum TerminalIpcChannels {
    /**
     * Communicates between the renderer process and shared process.
     */
    LocalPty = "localPty",
    /**
     * Communicates between the shared process and the pty host process.
     */
    PtyHost = "ptyHost",
    /**
     * Deals with logging from the pty host process.
     */
    Log = "log",
    /**
     * Enables the detection of unresponsive pty hosts.
     */
    Heartbeat = "heartbeat"
}
export declare const IPtyService: import("../../instantiation/common/instantiation.mjs").ServiceIdentifier<IPtyService>;
export declare const enum ProcessPropertyType {
    Cwd = "cwd",
    InitialCwd = "initialCwd",
    FixedDimensions = "fixedDimensions",
    Title = "title",
    ShellType = "shellType",
    HasChildProcesses = "hasChildProcesses",
    ResolvedShellLaunchConfig = "resolvedShellLaunchConfig",
    OverrideDimensions = "overrideDimensions",
    FailedShellIntegrationActivation = "failedShellIntegrationActivation",
    UsedShellIntegrationInjection = "usedShellIntegrationInjection"
}
export interface IProcessProperty<T extends ProcessPropertyType> {
    type: T;
    value: IProcessPropertyMap[T];
}
export interface IProcessPropertyMap {
    [ProcessPropertyType.Cwd]: string;
    [ProcessPropertyType.InitialCwd]: string;
    [ProcessPropertyType.FixedDimensions]: IFixedTerminalDimensions;
    [ProcessPropertyType.Title]: string;
    [ProcessPropertyType.ShellType]: TerminalShellType | undefined;
    [ProcessPropertyType.HasChildProcesses]: boolean;
    [ProcessPropertyType.ResolvedShellLaunchConfig]: IShellLaunchConfig;
    [ProcessPropertyType.OverrideDimensions]: ITerminalDimensionsOverride | undefined;
    [ProcessPropertyType.FailedShellIntegrationActivation]: boolean | undefined;
    [ProcessPropertyType.UsedShellIntegrationInjection]: boolean | undefined;
}
export interface IFixedTerminalDimensions {
    /**
     * The fixed columns of the terminal.
     */
    cols?: number;
    /**
     * The fixed rows of the terminal.
     */
    rows?: number;
}
export interface IPtyHostController {
    readonly onPtyHostExit?: Event<number>;
    readonly onPtyHostStart?: Event<void>;
    readonly onPtyHostUnresponsive?: Event<void>;
    readonly onPtyHostResponsive?: Event<void>;
    readonly onPtyHostRequestResolveVariables?: Event<IRequestResolveVariablesEvent>;
    restartPtyHost?(): Promise<void>;
    acceptPtyHostResolvedVariables?(requestId: number, resolved: string[]): Promise<void>;
}
export interface IPtyService extends IPtyHostController {
    readonly _serviceBrand: undefined;
    readonly onProcessData: Event<{
        id: number;
        event: IProcessDataEvent | string;
    }>;
    readonly onProcessReady: Event<{
        id: number;
        event: IProcessReadyEvent;
    }>;
    readonly onProcessReplay: Event<{
        id: number;
        event: IPtyHostProcessReplayEvent;
    }>;
    readonly onProcessOrphanQuestion: Event<{
        id: number;
    }>;
    readonly onDidRequestDetach: Event<{
        requestId: number;
        workspaceId: string;
        instanceId: number;
    }>;
    readonly onDidChangeProperty: Event<{
        id: number;
        property: IProcessProperty<any>;
    }>;
    readonly onProcessExit: Event<{
        id: number;
        event: number | undefined;
    }>;
    restartPtyHost?(): Promise<void>;
    shutdownAll?(): Promise<void>;
    acceptPtyHostResolvedVariables?(requestId: number, resolved: string[]): Promise<void>;
    createProcess(shellLaunchConfig: IShellLaunchConfig, cwd: string, cols: number, rows: number, unicodeVersion: '6' | '11', env: IProcessEnvironment, executableEnv: IProcessEnvironment, options: ITerminalProcessOptions, shouldPersist: boolean, workspaceId: string, workspaceName: string): Promise<number>;
    attachToProcess(id: number): Promise<void>;
    detachFromProcess(id: number, forcePersist?: boolean): Promise<void>;
    /**
     * Lists all orphaned processes, ie. those without a connected frontend.
     */
    listProcesses(): Promise<IProcessDetails[]>;
    start(id: number): Promise<ITerminalLaunchError | undefined>;
    shutdown(id: number, immediate: boolean): Promise<void>;
    input(id: number, data: string): Promise<void>;
    resize(id: number, cols: number, rows: number): Promise<void>;
    getInitialCwd(id: number): Promise<string>;
    getCwd(id: number): Promise<string>;
    getLatency(id: number): Promise<number>;
    acknowledgeDataEvent(id: number, charCount: number): Promise<void>;
    setUnicodeVersion(id: number, version: '6' | '11'): Promise<void>;
    processBinary(id: number, data: string): Promise<void>;
    /** Confirm the process is _not_ an orphan. */
    orphanQuestionReply(id: number): Promise<void>;
    updateTitle(id: number, title: string, titleSource: TitleEventSource): Promise<void>;
    updateIcon(id: number, userInitiated: boolean, icon: TerminalIcon, color?: string): Promise<void>;
    installAutoReply(match: string, reply: string): Promise<void>;
    uninstallAllAutoReplies(): Promise<void>;
    uninstallAutoReply(match: string): Promise<void>;
    getDefaultSystemShell(osOverride?: OperatingSystem): Promise<string>;
    getProfiles?(workspaceId: string, profiles: unknown, defaultProfile: unknown, includeDetectedProfiles?: boolean): Promise<ITerminalProfile[]>;
    getEnvironment(): Promise<IProcessEnvironment>;
    getWslPath(original: string, direction: 'unix-to-win' | 'win-to-unix'): Promise<string>;
    getRevivedPtyNewId(id: number): Promise<number | undefined>;
    setTerminalLayoutInfo(args: ISetTerminalLayoutInfoArgs): Promise<void>;
    getTerminalLayoutInfo(args: IGetTerminalLayoutInfoArgs): Promise<ITerminalsLayoutInfo | undefined>;
    reduceConnectionGraceTime(): Promise<void>;
    requestDetachInstance(workspaceId: string, instanceId: number): Promise<IProcessDetails | undefined>;
    acceptDetachInstanceReply(requestId: number, persistentProcessId?: number): Promise<void>;
    freePortKillProcess?(port: string): Promise<{
        port: string;
        processId: string;
    }>;
    /**
     * Serializes and returns terminal state.
     * @param ids The persistent terminal IDs to serialize.
     */
    serializeTerminalState(ids: number[]): Promise<string>;
    /**
     * Revives a workspaces terminal processes, these can then be reconnected to using the normal
     * flow for restoring terminals after reloading.
     */
    reviveTerminalProcesses(state: ISerializedTerminalState[], dateTimeFormatLocate: string): Promise<void>;
    refreshProperty<T extends ProcessPropertyType>(id: number, property: T): Promise<IProcessPropertyMap[T]>;
    updateProperty<T extends ProcessPropertyType>(id: number, property: T, value: IProcessPropertyMap[T]): Promise<void>;
    refreshIgnoreProcessNames?(names: string[]): Promise<void>;
}
/**
 * Serialized terminal state matching the interface that can be used across versions, the version
 * should be verified before using the state payload.
 */
export interface ICrossVersionSerializedTerminalState {
    version: number;
    state: unknown;
}
export interface ISerializedTerminalState {
    id: number;
    shellLaunchConfig: IShellLaunchConfig;
    processDetails: IProcessDetails;
    processLaunchConfig: IPersistentTerminalProcessLaunchConfig;
    unicodeVersion: '6' | '11';
    replayEvent: IPtyHostProcessReplayEvent;
    timestamp: number;
}
export interface IPersistentTerminalProcessLaunchConfig {
    env: IProcessEnvironment;
    executableEnv: IProcessEnvironment;
    options: ITerminalProcessOptions;
}
export interface IRequestResolveVariablesEvent {
    requestId: number;
    workspaceId: string;
    originalText: string[];
}
export declare enum HeartbeatConstants {
    /**
     * The duration between heartbeats
     */
    BeatInterval = 5000,
    /**
     * Defines a multiplier for BeatInterval for how long to wait before starting the second wait
     * timer.
     */
    FirstWaitMultiplier = 1.2,
    /**
     * Defines a multiplier for BeatInterval for how long to wait before telling the user about
     * non-responsiveness. The second timer is to avoid informing the user incorrectly when waking
     * the computer up from sleep
     */
    SecondWaitMultiplier = 1,
    /**
     * How long to wait before telling the user about non-responsiveness when they try to create a
     * process. This short circuits the standard wait timeouts to tell the user sooner and only
     * create process is handled to avoid additional perf overhead.
     */
    CreateProcessTimeout = 5000
}
export interface IHeartbeatService {
    readonly onBeat: Event<void>;
}
export interface IShellLaunchConfig {
    /**
     * The name of the terminal, if this is not set the name of the process will be used.
     */
    name?: string;
    /**
     * A string to follow the name of the terminal with, indicating the type of terminal
     */
    type?: 'Task' | 'Local';
    /**
     * The shell executable (bash, cmd, etc.).
     */
    executable?: string;
    /**
     * The CLI arguments to use with executable, a string[] is in argv format and will be escaped,
     * a string is in "CommandLine" pre-escaped format and will be used as is. The string option is
     * only supported on Windows and will throw an exception if used on macOS or Linux.
     */
    args?: string[] | string;
    /**
     * The current working directory of the terminal, this overrides the `terminal.integrated.cwd`
     * settings key.
     */
    cwd?: string | URI;
    /**
     * A custom environment for the terminal, if this is not set the environment will be inherited
     * from the VS Code process.
     */
    env?: ITerminalEnvironment;
    /**
     * Whether to ignore a custom cwd from the `terminal.integrated.cwd` settings key (e.g. if the
     * shell is being launched by an extension).
     */
    ignoreConfigurationCwd?: boolean;
    /**
     * The reconnection properties for this terminal
     */
    reconnectionProperties?: IReconnectionProperties;
    /** Whether to wait for a key press before closing the terminal. */
    waitOnExit?: WaitOnExitValue;
    /**
     * A string including ANSI escape sequences that will be written to the terminal emulator
     * _before_ the terminal process has launched, when a string is specified, a trailing \n is
     * added at the end. This allows for example the terminal instance to display a styled message
     * as the first line of the terminal. Use \x1b over \033 or \e for the escape control character.
     */
    initialText?: string | {
        text: string;
        trailingNewLine: boolean;
    };
    /**
     * Custom PTY/pseudoterminal process to use.
     */
    customPtyImplementation?: (terminalId: number, cols: number, rows: number) => ITerminalChildProcess;
    /**
     * A UUID generated by the extension host process for terminals created on the extension host process.
     */
    extHostTerminalId?: string;
    /**
     * This is a terminal that attaches to an already running terminal.
     */
    attachPersistentProcess?: {
        id: number;
        findRevivedId?: boolean;
        pid: number;
        title: string;
        titleSource: TitleEventSource;
        cwd: string;
        icon?: TerminalIcon;
        color?: string;
        hasChildProcesses?: boolean;
        fixedDimensions?: IFixedTerminalDimensions;
        environmentVariableCollections?: ISerializableEnvironmentVariableCollections;
        reconnectionProperties?: IReconnectionProperties;
        type?: TerminalType;
        waitOnExit?: WaitOnExitValue;
        hideFromUser?: boolean;
        isFeatureTerminal?: boolean;
    };
    /**
     * Whether the terminal process environment should be exactly as provided in
     * `TerminalOptions.env`. When this is false (default), the environment will be based on the
     * window's environment and also apply configured platform settings like
     * `terminal.integrated.env.windows` on top. When this is true, the complete environment must be
     * provided as nothing will be inherited from the process or any configuration.
     */
    strictEnv?: boolean;
    /**
     * Whether the terminal process environment will inherit VS Code's "shell environment" that may
     * get sourced from running a login shell depnding on how the application was launched.
     * Consumers that rely on development tools being present in the $PATH should set this to true.
     * This will overwrite the value of the inheritEnv setting.
     */
    useShellEnvironment?: boolean;
    /**
     * When enabled the terminal will run the process as normal but not be surfaced to the user
     * until `Terminal.show` is called. The typical usage for this is when you need to run
     * something that may need interactivity but only want to tell the user about it when
     * interaction is needed. Note that the terminals will still be exposed to all extensions
     * as normal.
     */
    hideFromUser?: boolean;
    /**
     * Whether this terminal is not a terminal that the user directly created and uses, but rather
     * a terminal used to drive some VS Code feature.
     */
    isFeatureTerminal?: boolean;
    /**
     * Whether this terminal was created by an extension.
     */
    isExtensionOwnedTerminal?: boolean;
    /**
     * The icon for the terminal, used primarily in the terminal tab.
     */
    icon?: TerminalIcon;
    /**
     * The color ID to use for this terminal. If not specified it will use the default fallback
     */
    color?: string;
    /**
     * When a parent terminal is provided via API, the group needs
     * to find the index in order to place the child
     * directly to the right of its parent.
     */
    parentTerminalId?: number;
    /**
     * The dimensions for the instance as set by the user
     * or via Size to Content Width
     */
    fixedDimensions?: IFixedTerminalDimensions;
    /**
     * Opt-out of the default terminal persistence on restart and reload
     */
    isTransient?: boolean;
    /**
     * Create a terminal without shell integration even when it's enabled
     */
    ignoreShellIntegration?: boolean;
}
export type WaitOnExitValue = boolean | string | ((exitCode: number) => string);
export interface ICreateContributedTerminalProfileOptions {
    icon?: URI | string | {
        light: URI;
        dark: URI;
    };
    color?: string;
    location?: TerminalLocation | {
        viewColumn: number;
        preserveState?: boolean;
    } | {
        splitActiveTerminal: boolean;
    };
}
export declare enum TerminalLocation {
    Panel = 1,
    Editor = 2
}
export declare const enum TerminalLocationString {
    TerminalView = "view",
    Editor = "editor"
}
export type TerminalIcon = ThemeIcon | URI | {
    light: URI;
    dark: URI;
};
export interface IShellLaunchConfigDto {
    name?: string;
    executable?: string;
    args?: string[] | string;
    cwd?: string | UriComponents;
    env?: ITerminalEnvironment;
    useShellEnvironment?: boolean;
    hideFromUser?: boolean;
    reconnectionProperties?: IReconnectionProperties;
    type?: 'Task' | 'Local';
    isFeatureTerminal?: boolean;
}
/**
 * A set of options for the terminal process. These differ from the shell launch config in that they
 * are set internally to the terminal component, not from the outside.
 */
export interface ITerminalProcessOptions {
    shellIntegration: {
        enabled: boolean;
    };
    windowsEnableConpty: boolean;
    environmentVariableCollections: ISerializableEnvironmentVariableCollections | undefined;
}
export interface ITerminalEnvironment {
    [key: string]: string | null | undefined;
}
export interface ITerminalLaunchError {
    message: string;
    code?: number;
}
export interface IProcessReadyEvent {
    pid: number;
    cwd: string;
    requiresWindowsMode?: boolean;
}
/**
 * An interface representing a raw terminal child process, this contains a subset of the
 * child_process.ChildProcess node.js interface.
 */
export interface ITerminalChildProcess {
    /**
     * A unique identifier for the terminal process. Note that the uniqueness only applies to a
     * given pty service connection, IDs will be duplicated for remote and local terminals for
     * example. The ID will be 0 if it does not support reconnection.
     */
    id: number;
    /**
     * Whether the process should be persisted across reloads.
     */
    shouldPersist: boolean;
    onProcessData: Event<IProcessDataEvent | string>;
    onProcessReady: Event<IProcessReadyEvent>;
    onDidChangeProperty: Event<IProcessProperty<any>>;
    onProcessExit: Event<number | undefined>;
    onRestoreCommands?: Event<ISerializedCommandDetectionCapability>;
    /**
     * Starts the process.
     *
     * @returns undefined when the process was successfully started, otherwise an object containing
     * information on what went wrong.
     */
    start(): Promise<ITerminalLaunchError | undefined>;
    /**
     * Detach the process from the UI and await reconnect.
     * @param forcePersist Whether to force the process to persist if it supports persistence.
     */
    detach?(forcePersist?: boolean): Promise<void>;
    /**
     * Frees the port and kills the process
     */
    freePortKillProcess?(port: string): Promise<{
        port: string;
        processId: string;
    }>;
    /**
     * Shutdown the terminal process.
     *
     * @param immediate When true the process will be killed immediately, otherwise the process will
     * be given some time to make sure no additional data comes through.
     */
    shutdown(immediate: boolean): void;
    input(data: string): void;
    processBinary(data: string): Promise<void>;
    resize(cols: number, rows: number): void;
    /**
     * Acknowledge a data event has been parsed by the terminal, this is used to implement flow
     * control to ensure remote processes to not get too far ahead of the client and flood the
     * connection.
     * @param charCount The number of characters being acknowledged.
     */
    acknowledgeDataEvent(charCount: number): void;
    /**
     * Sets the unicode version for the process, this drives the size of some characters in the
     * xterm-headless instance.
     */
    setUnicodeVersion(version: '6' | '11'): Promise<void>;
    getInitialCwd(): Promise<string>;
    getCwd(): Promise<string>;
    getLatency(): Promise<number>;
    refreshProperty<T extends ProcessPropertyType>(property: T): Promise<IProcessPropertyMap[T]>;
    updateProperty<T extends ProcessPropertyType>(property: T, value: IProcessPropertyMap[T]): Promise<void>;
}
export interface IReconnectConstants {
    graceTime: number;
    shortGraceTime: number;
    scrollback: number;
}
export declare const enum LocalReconnectConstants {
    /**
     * If there is no reconnection within this time-frame, consider the connection permanently closed...
    */
    GraceTime = 60000,
    /**
     * Maximal grace time between the first and the last reconnection...
    */
    ShortGraceTime = 6000
}
export declare const enum FlowControlConstants {
    /**
     * The number of _unacknowledged_ chars to have been sent before the pty is paused in order for
     * the client to catch up.
     */
    HighWatermarkChars = 100000,
    /**
     * After flow control pauses the pty for the client the catch up, this is the number of
     * _unacknowledged_ chars to have been caught up to on the client before resuming the pty again.
     * This is used to attempt to prevent pauses in the flowing data; ideally while the pty is
     * paused the number of unacknowledged chars would always be greater than 0 or the client will
     * appear to stutter. In reality this balance is hard to accomplish though so heavy commands
     * will likely pause as latency grows, not flooding the connection is the important thing as
     * it's shared with other core functionality.
     */
    LowWatermarkChars = 5000,
    /**
     * The number characters that are accumulated on the client side before sending an ack event.
     * This must be less than or equal to LowWatermarkChars or the terminal max never unpause.
     */
    CharCountAckSize = 5000
}
export interface IProcessDataEvent {
    data: string;
    trackCommit: boolean;
    /**
     * When trackCommit is set, this will be set to a promise that resolves when the data is parsed.
     */
    writePromise?: Promise<void>;
}
export interface ITerminalDimensions {
    /**
     * The columns of the terminal.
     */
    cols: number;
    /**
     * The rows of the terminal.
     */
    rows: number;
}
export interface ITerminalProfile {
    profileName: string;
    path: string;
    isDefault: boolean;
    /**
     * Whether the terminal profile contains a potentially unsafe path. For example, the path
     *  `C:\Cygwin` is the default install for Cygwin on Windows, but it could be created by any
     * user in a multi-user environment. As such, we don't want to blindly present it as a profile
     * without a warning.
     */
    isUnsafePath?: boolean;
    isAutoDetected?: boolean;
    /**
     * Whether the profile path was found on the `$PATH` environment variable, if so it will be
     * cleaner to display this profile in the UI using only `basename(path)`.
     */
    isFromPath?: boolean;
    args?: string | string[] | undefined;
    env?: ITerminalEnvironment;
    overrideName?: boolean;
    color?: string;
    icon?: ThemeIcon | URI | {
        light: URI;
        dark: URI;
    };
}
export interface ITerminalDimensionsOverride extends Readonly<ITerminalDimensions> {
    /**
     * indicate that xterm must receive these exact dimensions, even if they overflow the ui!
     */
    forceExactSize?: boolean;
}
export declare const enum ProfileSource {
    GitBash = "Git Bash",
    Pwsh = "PowerShell"
}
export interface IBaseUnresolvedTerminalProfile {
    args?: string | string[] | undefined;
    isAutoDetected?: boolean;
    overrideName?: boolean;
    icon?: string | ThemeIcon | URI | {
        light: URI;
        dark: URI;
    };
    color?: string;
    env?: ITerminalEnvironment;
}
type OneOrN<T> = T | T[];
export interface ITerminalUnsafePath {
    path: string;
    isUnsafe: true;
}
export interface ITerminalExecutable extends IBaseUnresolvedTerminalProfile {
    path: OneOrN<string | ITerminalUnsafePath>;
}
export interface ITerminalProfileSource extends IBaseUnresolvedTerminalProfile {
    source: ProfileSource;
}
export interface ITerminalProfileContribution {
    title: string;
    id: string;
    icon?: URI | {
        light: URI;
        dark: URI;
    } | string;
    color?: string;
}
export interface IExtensionTerminalProfile extends ITerminalProfileContribution {
    extensionIdentifier: string;
}
export type ITerminalProfileObject = ITerminalExecutable | ITerminalProfileSource | IExtensionTerminalProfile | null;
export interface IShellIntegration {
    readonly capabilities: ITerminalCapabilityStore;
    readonly status: ShellIntegrationStatus;
    readonly onDidChangeStatus: Event<ShellIntegrationStatus>;
    deserialize(serialized: ISerializedCommandDetectionCapability): void;
}
export interface ITerminalContributions {
    profiles?: ITerminalProfileContribution[];
    quickFixes?: ITerminalCommandSelector[];
}
export declare const enum ShellIntegrationStatus {
    /** No shell integration sequences have been encountered. */
    Off = 0,
    /** Final term shell integration sequences have been encountered. */
    FinalTerm = 1,
    /** VS Code shell integration sequences have been encountered. Supercedes FinalTerm. */
    VSCode = 2
}
export declare enum TerminalExitReason {
    Unknown = 0,
    Shutdown = 1,
    Process = 2,
    User = 3,
    Extension = 4
}
export {};