import { Observable } from 'rxjs';
import { Destructible } from './helpers';
import { SFTP } from './sftp';
import { Channel, NewChannel } from './channel';
import { ClientEventInterface } from './events';
import { SshKeyPair, KeyboardInteractiveAuthenticationPrompt, SshClient, SshPublicKey, SshTransport } from './native';
import { AgentConnectionSpec } from './agent';
export declare class KeyPair {
    protected inner: SshKeyPair;
    private constructor();
    get algorithm(): string;
    static parse(data: string, passphrase?: string): Promise<KeyPair>;
}
export interface X11ChannelOpenEvent {
    readonly channel: NewChannel;
    readonly clientAddress: string;
    readonly clientPort: number;
}
export interface TCPChannelOpenEvent {
    readonly channel: NewChannel;
    readonly targetAddress: string;
    readonly targetPort: number;
    readonly clientAddress: string;
    readonly clientPort: number;
}
export type KeyboardInteractiveAuthenticationState = {
    state: 'failure';
    remainingMethods: string[];
} | {
    state: 'infoRequest';
    name: string;
    instructions: string;
    prompts: () => KeyboardInteractiveAuthenticationPrompt[];
};
export interface AuthFailure {
    remainingMethods: string[];
}
export interface Config {
    preferred?: {
        ciphers?: string[];
        kex?: string[];
        key?: string[];
        mac?: string[];
        compression?: string[];
    };
    connectionTimeoutSeconds?: number;
    keepaliveIntervalSeconds?: number;
    keepaliveCountMax?: number;
}
export declare class SSHClient extends Destructible {
    private client;
    private events;
    readonly disconnect$: Observable<void>;
    readonly banner$: Observable<string>;
    private constructor();
    static connect(transport: SshTransport, serverKeyCallback: (key: SshPublicKey) => Promise<boolean>, config?: Config): Promise<SSHClient>;
    protected destruct(): void;
    authenticateNone(username: string): Promise<AuthenticatedSSHClient | AuthFailure>;
    authenticateWithPassword(username: string, password: string): Promise<AuthenticatedSSHClient | AuthFailure>;
    private _hashAlg;
    authenticateWithKeyPair(username: string, keyPair: KeyPair, hashAlgorithm: 'sha1' | 'sha256' | 'sha512' | null): Promise<AuthenticatedSSHClient | AuthFailure>;
    startKeyboardInteractiveAuthentication(username: string): Promise<KeyboardInteractiveAuthenticationState>;
    continueKeyboardInteractiveAuthentication(responses: string[]): Promise<AuthenticatedSSHClient | KeyboardInteractiveAuthenticationState>;
    authenticateWithAgent(username: string, connection: AgentConnectionSpec): Promise<AuthenticatedSSHClient | AuthFailure>;
    /**
     * Authenticate using SSH agent with a specific public key identity.
     * This is useful when you have multiple keys in the agent and want to use a specific one,
     * avoiding the server's authentication attempt limit.
     * @param username SSH username
     * @param connection Agent connection specification
     * @param publicKey The specific public key to use for authentication
     */
    authenticateWithAgentIdentity(username: string, connection: AgentConnectionSpec, publicKey: SshPublicKey): Promise<AuthenticatedSSHClient | AuthFailure>;
    disconnect(): Promise<void>;
    private intoAuthenticated;
}
export declare class AuthenticatedSSHClient extends Destructible {
    private client;
    private events;
    readonly disconnect$: Observable<void>;
    readonly x11ChannelOpen$: Observable<X11ChannelOpenEvent>;
    readonly tcpChannelOpen$: Observable<TCPChannelOpenEvent>;
    readonly agentChannelOpen$: Observable<NewChannel>;
    constructor(client: SshClient, events: ClientEventInterface);
    openSessionChannel(): Promise<NewChannel>;
    openTCPForwardChannel(options: {
        addressToConnectTo: string;
        portToConnectTo: number;
        originatorAddress: string;
        originatorPort: number;
    }): Promise<NewChannel>;
    forwardTCPPort(addressToBind: string, portToBind: number): Promise<number>;
    stopForwardingTCPPort(addressToBind: string, portToBind: number): Promise<void>;
    disconnect(): Promise<void>;
    activateChannel(ch: NewChannel): Promise<Channel>;
    activateSFTP(ch: NewChannel): Promise<SFTP>;
    private wrapChannel;
}
export { KeyboardInteractiveAuthenticationPrompt, SshPublicKey, SshTransport, SshChannel, NewSshChannel, SftpFileType as SFTPFileType, supportedCiphers as getSupportedCiphers, supportedKexAlgorithms as getSupportedKexAlgorithms, supportedMacs as getSupportedMACs, supportedCompressionAlgorithms as getSupportedCompressionAlgorithms, supportedKeyTypes as getSupportedKeyTypes, OPEN_APPEND, OPEN_CREATE, OPEN_READ, OPEN_TRUNCATE, OPEN_WRITE, SftpFile as SFTPFile, isPageantRunning, HashAlgorithm, parsePublicKey, } from './native';
export { SFTP, SFTPDirectoryEntry, SFTPMetadata, } from './sftp';
export { AgentConnectionSpec, SSHAgentStream } from './agent';
export { Channel, NewChannel };