node-ssh

connection: any;

connect: (givenConfig: Config) => Promise<this>;

dispose: () => void;

exec: {
    (
        command: string,
        parameters: string[],
        options?: SSHExecOptions & { stream?: 'stdout' | 'stderr' }
    ): Promise<string>;
    (
        command: string,
        parameters: string[],
        options?: SSHExecOptions & { stream: 'both' }
    ): Promise<SSHExecCommandResponse>;
};

execCommand: (
    givenCommand: string,
    options?: SSHExecCommandOptions
) => Promise<SSHExecCommandResponse>;

forwardIn: (
    remoteAddr: string,
    remotePort: number,
    onConnection?: SSHForwardInListener
) => Promise<SSHForwardInDetails>;

forwardInStreamLocal: (
    socketPath: string,
    onConnection?: SSHForwardInStreamLocalListener
) => Promise<SSHForwardInStreamLocalDetails>;

forwardOut: (
    srcIP: string,
    srcPort: number,
    dstIP: string,
    dstPort: number
) => Promise<Channel>;

forwardOutStreamLocal: (socketPath: string) => Promise<Channel>;

getDirectory: (
    localDirectory: string,
    remoteDirectory: string,
    {
        concurrency,
        sftp: givenSftp,
        transferOptions,
        recursive,
        tick,
        validate,
    }?: SSHGetPutDirectoryOptions
) => Promise<boolean>;

getFile: (
    localFile: string,
    remoteFile: string,
    givenSftp?: SFTPWrapper | null,
    transferOptions?: TransferOptions | null
) => Promise<void>;

isConnected: () => boolean;

mkdir: (
    path: string,
    method?: SSHMkdirMethod,
    givenSftp?: SFTPWrapper | null
) => Promise<void>;

putDirectory: (
    localDirectory: string,
    remoteDirectory: string,
    {
        concurrency,
        sftp: givenSftp,
        transferOptions,
        recursive,
        tick,
        validate,
    }?: SSHGetPutDirectoryOptions
) => Promise<boolean>;

putFile: (
    localFile: string,
    remoteFile: string,
    givenSftp?: SFTPWrapper | null,
    transferOptions?: TransferOptions | null
) => Promise<void>;

putFiles: (
    files: { local: string; remote: string }[],
    { concurrency, sftp: givenSftp, transferOptions }?: SSHPutFilesOptions
) => Promise<void>;

requestSFTP: () => Promise<SFTPWrapper>;

requestShell: (
    options?: PseudoTtyOptions | ShellOptions | false
) => Promise<ClientChannel>;

withSFTP: (callback: (sftp: SFTPWrapper) => Promise<void>) => Promise<void>;

withShell: (
    callback: (channel: ClientChannel) => Promise<void>,
    options?: PseudoTtyOptions | ShellOptions | false
) => Promise<void>;

constructor(message: string, code?: string);

code: string;

cwd?: string;

encoding?: BufferEncoding;

execOptions?: ExecOptions;

noTrim?: boolean;

onChannel?: (clientChannel: ClientChannel) => void;

onStderr?: (chunk: Buffer) => void;

onStdout?: (chunk: Buffer) => void;

stdin?: string | stream.Readable;

code: number | null;

signal: string | null;

stderr: string;

stdout: string;

stream?: 'stdout' | 'stderr' | 'both';

port: number;

dispose: () => Promise<void>;

dispose: () => Promise<void>;

recursive?: boolean;

tick?: (localFile: string, remoteFile: string, error: Error | null) => void;

validate?: (path: string) => boolean;

concurrency?: number;

sftp?: SFTPWrapper | null;

transferOptions?: TransferOptions;