Channels and forwarding

export declare const AUTOMATIC_TUNNEL_UNIT = 2147483647;

export default class Channel {
    client: Client | ServerClient;
    channel_type: string;
    localId: number;
    remoteId: number | undefined;
    local_initial_window_size: number;
    remote_initial_window_size: number;
    local_maximum_packet_size: number;
    remote_maximum_packet_size: number;
    local_window_size: number;
    remote_window_size: number;
    constructor(client: Client | ServerClient, channel_type: string, clientArgs?: Buffer);
    /** Owned channel-open arguments. Each access returns a defensive copy. */
    get clientArgs(): Buffer;
    /** Owned channel-open confirmation arguments, once configured. */
    get serverArgs(): Buffer | undefined;
    set serverArgs(value: Buffer | undefined);
    get isOpen(): boolean;
    get isFullyClosed(): boolean;
    get hasSentEndOfWrite(): boolean;
    get hasReceivedEndOfWrite(): boolean;
    debug(...msg: unknown[]): void;
    configureRemote(open: ChannelOpen): void;
    confirmOpen(confirmation: ChannelOpenConfirmation): void;
    failOpen(failure: ChannelOpenFailure): void;
    waitUntilOpen(): Promise<void>;
    getChannelOpenPacket(): ChannelOpen;
    getChannelOpenConfirmationPacket(): ChannelOpenConfirmation;
    getServerArgsBuffer(): Buffer;
    preHandleChannelRequest(request: ChannelRequest): Promise<boolean>;
    handleChannelRequest(request: ChannelRequest): Promise<void>;
    sendData(data: Buffer): Promise<void>;
    sendExtendedData(dataType: number, data: Buffer): Promise<void>;
    /**
     * Send a channel notification which cannot receive a protocol reply.
     *
     * Use request() for a request whose success or failure must be awaited.
     */
    sendRequest(type: string, args?: Buffer): void;
    request(type: string, args?: Buffer, wantReply?: boolean): Promise<void>;
    receiveRequestSuccess(): void;
    receiveRequestFailure(): void;
    receiveWindowAdjust(bytesToAdd: number): void;
    receiveData(data: Buffer): void;
    receiveExtendedData(dataType: number, data: Buffer): void;
    receiveEOF(): void;
    receiveClose(): void;
    resumeInput(): void;
    sendEOF(): void;
    /** Ask the peer to stop sending channel data while keeping this channel open. */
    sendEndOfWrite(force?: boolean): boolean;
    receiveEndOfWrite(): void;
    close(): void;
    terminate(): void;
    abort(error?: Error): void;
}

export default class ClientAgentChannel extends ClientChannel {
    static channelType: string;
    static channelTypes: readonly string[];
    constructor(client: Client, packet: ChannelOpen);
}

export default class ClientChannel extends Duplex {
    readonly hooker: Hooker<ClientChannelHooker>;
    readonly client: Client;
    readonly type: string;
    readonly localId: number;
    readonly localInitialWindowSize: number;
    readonly localMaximumPacketSize: number;
    readonly stderr: ClientChannelStderr;
    remoteId?: number;
    remoteWindowSize: number;
    remoteMaximumPacketSize: number;
    localWindowSize: number;
    exitCode?: number | null;
    exitSignal?: string;
    exitCoreDumped?: boolean;
    exitErrorMessage?: string;
    exitLanguageTag?: string;
    constructor(client: Client, type: string, options?: {
        initialWindowSize?: number;
        maximumPacketSize?: number;
    });
    get isOpen(): boolean;
    get isFullyClosed(): boolean;
    get hasSentEndOfWrite(): boolean;
    get hasReceivedEndOfWrite(): boolean;
    getOpenPacket(args?: Buffer): ChannelOpen;
    getOpenConfirmationPacket(): ChannelOpenConfirmation;
    waitUntilOpen(): Promise<void>;
    abort(error?: Error | null): void;
    confirmOpen(packet: ChannelOpenConfirmation): void;
    acceptOpen(packet: ChannelOpen): void;
    failOpen(packet: ChannelOpenFailure): void;
    request(type: string, args?: Buffer, wantReply?: boolean): Promise<void>;
    receiveRequestSuccess(): void;
    receiveRequestFailure(): void;
    receiveWindowAdjust(bytesToAdd: number): void;
    receiveData(data: Buffer): void;
    receiveExtendedData(dataType: number, data: Buffer): void;
    receiveEOF(): void;
    receiveClose(): void;
    receiveRequest(packet: ChannelRequest): Promise<void>;
    eof(): this;
    /** Ask the peer to stop sending channel data while keeping this channel open. */
    sendEndOfWrite(force?: boolean): boolean;
    close(): this;
    _read(): void;
    _write(data: Buffer | string, encoding: BufferEncoding, callback: WriteCallback): void;
    _final(callback: WriteCallback): void;
    _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
    /** Send channel data and resolve after SSH flow control permits every resulting packet. */
    sendData(data: Buffer | string, encoding?: BufferEncoding): Promise<void>;
}

export type ClientChannelHooker = {
    endOfWrite: [
    ];
    request: [
        context: ClientChannelRequestContext,
        controller: ClientChannelRequestController
    ];
};

export type ClientChannelRequestContext = Readonly<{
    type: string;
    args: Buffer;
    wantReply: boolean;
}>;

export interface ClientChannelRequestController {
    success: boolean;
}

export default class ClientDirectStreamLocalChannel extends ClientChannel {
    static channelType: string;
    readonly socketPath: string;
    constructor(client: Client, socketPath: string);
    getOpenPacket(): ChannelOpen;
}

export default class ClientForwardedStreamLocalChannel extends ClientChannel {
    static channelType: string;
    readonly details: Readonly<StreamLocalConnectionDetails>;
    constructor(client: Client, packet: ChannelOpen);
    static parseDetails(raw: Buffer): StreamLocalConnectionDetails;
}

export default class ClientForwardedTCPIPChannel extends ClientChannel {
    readonly details: Readonly<TCPIPConnectionDetails>;
    constructor(client: Client, packet: ChannelOpen);
    static parseDetails(raw: Buffer): TCPIPConnectionDetails;
}

export interface ClientPtyOptions {
    term?: string;
    columns?: number;
    cols?: number;
    rows?: number;
    width?: number;
    height?: number;
    modes?: TerminalModeSettings;
}

export default class ClientSessionChannel extends ClientChannel {
    constructor(client: Client);
    exec(command: string): Promise<void>;
    shell(): Promise<void>;
    requestPty(options?: ClientPtyOptions): Promise<void>;
    setEnv(name: string, value: string, wantReply?: boolean): Promise<void>;
    openssh_forwardAgent(): Promise<void>;
    /** Request RFC 9987 agent forwarding, with the pre-standardization compatibility fallback. */
    forwardAgent(): Promise<void>;
    requestX11(options?: ClientX11Options): Promise<Readonly<ClientX11Request>>;
    subsystem(name: string): Promise<void>;
    setWindow(dimensions: ClientWindowDimensions): Promise<void>;
    signal(name: string): Promise<void>;
    /** Request SIGINFO on an OpenSSH-compatible BSD-derived server. */
    sendInfoSignal(): Promise<void>;
    sendBreak(duration?: number): Promise<void>;
    break(duration?: number): Promise<void>;
    receiveRequest(packet: ChannelRequest): Promise<void>;
}

export default class ClientTCPIPChannel extends ClientChannel {
    readonly details: Readonly<TCPIPConnectionDetails>;
    constructor(client: Client, details: TCPIPConnectionDetails);
    getOpenPacket(): import("../packets/ChannelOpen.js").default;
}

export default class ClientTunnelChannel extends ClientChannel {
    static channelType: string;
    readonly events: EventEmitter<TunnelEvents>;
    readonly mode: TunnelMode;
    readonly unit: number;
    constructor(client: Client, mode: TunnelMode, unit?: number);
    getOpenPacket(): ChannelOpen;
    sendIPv4(packet: Buffer): Promise<void>;
    sendIPv6(packet: Buffer): Promise<void>;
    sendFrame(frame: Buffer): Promise<void>;
    sendData(data: Buffer | string, encoding?: BufferEncoding): Promise<void>;
    receiveData(data: Buffer): void;
    _write(data: Buffer | string, encoding: BufferEncoding, callback: WriteCallback): void;
}

export interface ClientWindowDimensions {
    columns: number;
    rows: number;
    width?: number;
    height?: number;
}

export default class ClientX11Channel extends ClientChannel {
    static channelType: string;
    readonly details: Readonly<X11ConnectionDetails>;
    constructor(client: Client, packet: ChannelOpen);
    static parseDetails(raw: Buffer): X11ConnectionDetails;
}

export interface ClientX11Options {
    single?: boolean;
    protocol?: string;
    cookie?: string | Buffer;
    screen?: number;
}

export interface ClientX11Request {
    single: boolean;
    protocol: string;
    cookie: string;
    screen: number;
}

export declare const DEFAULT_CHANNEL_PACKET_SIZE: number;

export declare const DEFAULT_CHANNEL_WINDOW_SIZE: number;

export declare const DEFAULT_SERVER_CHANNEL_PACKET_SIZE: number;

export declare const DEFAULT_SERVER_CHANNEL_WINDOW_SIZE: number;

export default class DirectStreamLocalChannel extends Channel {
    static channel_type: string;
    readonly details: Readonly<StreamLocalConnectionDetails>;
    readonly stream: ChannelStream;
    constructor(client: Client | ServerClient, channelType: string, clientArgs?: Buffer<ArrayBuffer>);
}

export default class DirectTCPIPChannel extends Channel {
    static channel_type: string;
    readonly details: Readonly<TCPIPConnectionDetails>;
    readonly stream: DirectTCPIPStream;
    constructor(client: Client | ServerClient, channelType: string, clientArgs?: Buffer<ArrayBuffer>);
}

export default class ForwardedAgentChannel extends Channel {
    static channel_type: string;
    readonly stream: ChannelStream;
    constructor(client: ServerClient, protocol?: AgentForwardingProtocol);
}

export default class ForwardedStreamLocalChannel extends Channel {
    static channel_type: string;
    readonly details: Readonly<StreamLocalConnectionDetails>;
    readonly stream: ChannelStream;
    constructor(client: ServerClient, socketPath: string);
}

export default class ForwardedTCPIPChannel extends Channel {
    static channel_type: string;
    readonly details: Readonly<TCPIPConnectionDetails>;
    readonly stream: ForwardedTCPIPStream;
    constructor(client: ServerClient, details: TCPIPConnectionDetails);
}

export default class ForwardedX11Channel extends Channel {
    static channel_type: string;
    readonly details: Readonly<X11ConnectionDetails>;
    readonly stream: ChannelStream;
    constructor(client: ServerClient, details: X11ConnectionDetails);
}

export interface SessionBreakRequestContext {
    /** Requested BREAK duration in milliseconds; zero asks for the device default. */
    duration: number;
}

export default class SessionChannel extends Channel {
    static channel_type: string;
    hooker: Hooker<SessionChannelHooker>;
    events: EventEmitter<SessionChannelEvents>;
    consumed: boolean;
    shell: Shell | undefined;
    sftp: SFTPServer | undefined;
    publicKey: PublicKeySubsystemServer | undefined;
    pty: Readonly<SessionPtyInfo> | undefined;
    x11: Readonly<SessionX11Request> | undefined;
    get env(): ReadonlyMap<string, string>;
    constructor(client: Client | ServerClient, channel_type: string, clientArgs?: Buffer<ArrayBuffer>);
    handleChannelRequest(request: ChannelRequest): Promise<void>;
    parsePtyRequest(raw: Buffer): {
        term: string;
        columns: number;
        rows: number;
        width: number;
        height: number;
        modes: ReadonlyMap<number, number>;
    };
    parseEnvRequest(raw: Buffer): {
        key: string;
        value: string;
    };
    assertNotConsumed(): void;
    parseExecRequest(raw: Buffer): {
        command: string;
    };
    parseShellRequest(raw: Buffer): {};
    parseSubsystemRequest(raw: Buffer): {
        subsystem: string;
    };
    parseWindowChange(raw: Buffer): SessionWindowDimensions;
    static parseX11Request(raw: Buffer): SessionX11Request;
    parseSignalRequest(raw: Buffer): string;
    parseTerminalModes(raw: Buffer): ReadonlyMap<number, number>;
}

export interface SessionChannelEvents {
    agentForward: [
    ];
    break: [
        duration: number
    ];
    env: [
        name: string,
        value: string
    ];
    endOfWrite: [
    ];
    exec: [
        command: string,
        shell: Shell
    ];
    pty: [
        pty: Readonly<SessionPtyInfo>
    ];
    shell: [
        Shell
    ];
    signal: [
        signal: string
    ];
    sftp: [
        server: SFTPServer
    ];
    publicKey: [
        server: PublicKeySubsystemServer
    ];
    subsystem: [
        name: string,
        shell: Shell
    ];
    windowChange: [
        dimensions: Readonly<SessionWindowDimensions>
    ];
    x11: [
        request: Readonly<SessionX11Request>
    ];
}

export type SessionChannelHooker = {
    breakRequest: [
        breakRequestContext: Readonly<SessionBreakRequestContext>,
        breakRequestController: SessionChannelHookerBreakRequestController
    ];
    agentForwardRequest: [
        agentForwardRequestController: SessionChannelHookerAgentForwardRequestController
    ];
    execRequest: [
        execRequestContext: Readonly<SessionChannelHookerExecRequestContext>,
        execRequestController: SessionChannelHookerExecRequestController
    ];
    envRequest: [
        envRequestContext: Readonly<SessionChannelHookerEnvRequestContext>,
        envRequestController: SessionChannelHookerEnvRequestController
    ];
    endOfWrite: [
    ];
    shellRequest: [
        shellRequestController: SessionChannelHookerShellRequestController
    ];
    signal: [
        signalContext: Readonly<SessionSignalContext>
    ];
    ptyRequest: [
        ptyRequestContext: Readonly<SessionPtyInfo>,
        ptyRequestController: SessionChannelHookerPtyRequestController
    ];
    subsystemRequest: [
        subsystemRequestContext: Readonly<SessionChannelHookerSubsystemRequestContext>,
        subsystemRequestController: SessionChannelHookerSubsystemRequestController
    ];
    windowChange: [
        dimensions: Readonly<SessionWindowDimensions>
    ];
    x11Request: [
        x11RequestContext: Readonly<SessionX11Request>,
        x11RequestController: SessionChannelHookerX11RequestController
    ];
};

export interface SessionChannelHookerAgentForwardRequestController {
    success: boolean;
}

export interface SessionChannelHookerBreakRequestController {
    success: boolean;
}

export interface SessionChannelHookerEnvRequestContext {
    key: string;
    value: string;
}

export interface SessionChannelHookerEnvRequestController {
    success: boolean;
}

export interface SessionChannelHookerExecRequestContext {
    command: string;
}

export interface SessionChannelHookerExecRequestController {
    success: boolean;
}

export interface SessionChannelHookerPtyRequestController {
    success: boolean;
}

export interface SessionChannelHookerShellRequestController {
    success: boolean;
}

export interface SessionChannelHookerSubsystemRequestContext {
    subsystem: string;
}

export interface SessionChannelHookerSubsystemRequestController {
    success: boolean;
    sftp?: SFTPServerOptions;
    publicKey?: PublicKeySubsystemServerOptions;
}

export interface SessionChannelHookerX11RequestController {
    success: boolean;
}

export interface SessionPtyInfo {
    term: string;
    columns: number;
    rows: number;
    width: number;
    height: number;
    modes: ReadonlyMap<number, number>;
}

export interface SessionSignalContext {
    signal: string;
}

export interface SessionWindowDimensions {
    columns: number;
    rows: number;
    width: number;
    height: number;
}

export interface SessionX11Request {
    single: boolean;
    protocol: string;
    cookie: string;
    screen: number;
}

export default class Shell extends Duplex {
    readonly channel: SessionChannel;
    readonly stdin: this;
    readonly stdout: this;
    readonly stderr: Writable;
    constructor(channel: SessionChannel);
    _read(): void;
    _write(data: Buffer | string, encoding: BufferEncoding, callback: WriteCallback): void;
    /** Send standard output and resolve after every resulting channel-data packet is written. */
    writeStdout(data: Buffer | string, encoding?: BufferEncoding): Promise<void>;
    /** Send standard error and resolve after every resulting extended-data packet is written. */
    writeStderr(data: Buffer | string, encoding?: BufferEncoding): Promise<void>;
    _final(callback: WriteCallback): void;
    _destroy(error: Error | null, callback: WriteCallback): void;
    receive(data: Buffer): boolean;
    receiveEOF(): void;
    closeFromRemote(): void;
    eof(): this;
    /** Ask an OpenSSH peer to stop writing to this session without closing the channel. */
    sendEndOfWrite(force?: boolean): boolean;
    close(): this;
    setXonXoff(clientCanDo: boolean): this;
    exit(status: number): this;
    exit(signal: string, coreDumped?: boolean, message?: string, languageTag?: string): this;
}

export interface StreamLocalConnectionDetails {
    socketPath: string;
}

export interface TCPIPConnectionDetails {
    destinationHost: string;
    destinationPort: number;
    sourceHost: string;
    sourcePort: number;
}

/** RFC 4254 section 8 and RFC 8160 terminal-mode opcodes. */
export declare const TerminalMode: Readonly<{
    readonly TTY_OP_END: 0;
    readonly VINTR: 1;
    readonly VQUIT: 2;
    readonly VERASE: 3;
    readonly VKILL: 4;
    readonly VEOF: 5;
    readonly VEOL: 6;
    readonly VEOL2: 7;
    readonly VSTART: 8;
    readonly VSTOP: 9;
    readonly VSUSP: 10;
    readonly VDSUSP: 11;
    readonly VREPRINT: 12;
    readonly VWERASE: 13;
    readonly VLNEXT: 14;
    readonly VFLUSH: 15;
    readonly VSWTCH: 16;
    readonly VSTATUS: 17;
    readonly VDISCARD: 18;
    readonly IGNPAR: 30;
    readonly PARMRK: 31;
    readonly INPCK: 32;
    readonly ISTRIP: 33;
    readonly INLCR: 34;
    readonly IGNCR: 35;
    readonly ICRNL: 36;
    readonly IUCLC: 37;
    readonly IXON: 38;
    readonly IXANY: 39;
    readonly IXOFF: 40;
    readonly IMAXBEL: 41;
    readonly IUTF8: 42;
    readonly ISIG: 50;
    readonly ICANON: 51;
    readonly XCASE: 52;
    readonly ECHO: 53;
    readonly ECHOE: 54;
    readonly ECHOK: 55;
    readonly ECHONL: 56;
    readonly NOFLSH: 57;
    readonly TOSTOP: 58;
    readonly IEXTEN: 59;
    readonly ECHOCTL: 60;
    readonly ECHOKE: 61;
    readonly PENDIN: 62;
    readonly OPOST: 70;
    readonly OLCUC: 71;
    readonly ONLCR: 72;
    readonly OCRNL: 73;
    readonly ONOCR: 74;
    readonly ONLRET: 75;
    readonly CS7: 90;
    readonly CS8: 91;
    readonly PARENB: 92;
    readonly PARODD: 93;
    readonly TTY_OP_ISPEED: 128;
    readonly TTY_OP_OSPEED: 129;
}>;

export type TerminalModeOpcode = (typeof TerminalMode)[keyof typeof TerminalMode];

/** Plural compatibility alias for callers that prefer a registry-style name. */
export declare const TerminalModes: Readonly<{
    readonly TTY_OP_END: 0;
    readonly VINTR: 1;
    readonly VQUIT: 2;
    readonly VERASE: 3;
    readonly VKILL: 4;
    readonly VEOF: 5;
    readonly VEOL: 6;
    readonly VEOL2: 7;
    readonly VSTART: 8;
    readonly VSTOP: 9;
    readonly VSUSP: 10;
    readonly VDSUSP: 11;
    readonly VREPRINT: 12;
    readonly VWERASE: 13;
    readonly VLNEXT: 14;
    readonly VFLUSH: 15;
    readonly VSWTCH: 16;
    readonly VSTATUS: 17;
    readonly VDISCARD: 18;
    readonly IGNPAR: 30;
    readonly PARMRK: 31;
    readonly INPCK: 32;
    readonly ISTRIP: 33;
    readonly INLCR: 34;
    readonly IGNCR: 35;
    readonly ICRNL: 36;
    readonly IUCLC: 37;
    readonly IXON: 38;
    readonly IXANY: 39;
    readonly IXOFF: 40;
    readonly IMAXBEL: 41;
    readonly IUTF8: 42;
    readonly ISIG: 50;
    readonly ICANON: 51;
    readonly XCASE: 52;
    readonly ECHO: 53;
    readonly ECHOE: 54;
    readonly ECHOK: 55;
    readonly ECHONL: 56;
    readonly NOFLSH: 57;
    readonly TOSTOP: 58;
    readonly IEXTEN: 59;
    readonly ECHOCTL: 60;
    readonly ECHOKE: 61;
    readonly PENDIN: 62;
    readonly OPOST: 70;
    readonly OLCUC: 71;
    readonly ONLCR: 72;
    readonly OCRNL: 73;
    readonly ONOCR: 74;
    readonly ONLRET: 75;
    readonly CS7: 90;
    readonly CS8: 91;
    readonly PARENB: 92;
    readonly PARODD: 93;
    readonly TTY_OP_ISPEED: 128;
    readonly TTY_OP_OSPEED: 129;
}>;

export type TerminalModeSettings = Readonly<Record<number, number>> | ReadonlyMap<number, number>;

export declare enum TunnelAddressFamily {
    IPv4 = 2,
    IPv6 = 24
}

export default class TunnelChannel extends Channel {
    static channel_type: string;
    readonly events: EventEmitter<TunnelEvents>;
    readonly mode: TunnelMode;
    readonly unit: number;
    constructor(client: Client | ServerClient, channelType: string, clientArgs?: Buffer<ArrayBuffer>);
    sendIPv4(packet: Buffer): Promise<void>;
    sendIPv6(packet: Buffer): Promise<void>;
    sendFrame(frame: Buffer): Promise<void>;
    sendData(data: Buffer): Promise<void>;
}

export interface TunnelEvents {
    packet: [
        packet: Readonly<TunnelIPPacket>
    ];
    frame: [
        frame: Buffer
    ];
}

export interface TunnelIPPacket {
    readonly family: TunnelAddressFamily.IPv4 | TunnelAddressFamily.IPv6;
    readonly data: Buffer;
}

export declare enum TunnelMode {
    PointToPoint = 1,
    Ethernet = 2
}

export interface X11ConnectionDetails {
    originatorAddress: string;
    originatorPort: number;
}