import { Transport } from './transport';
export type { Transport } from './transport';
export { WebSocketTransport, CustomTransport } from './transport';
export { SecureTunnelTransport, TunnelMessageType } from './aws-iot-tunnel';
export type { SecureTunnelConfig, TunnelMessage } from './aws-iot-tunnel';
export interface ConnectionOptions {
    host: string;
    port: number;
    user: string;
    password?: string;
    privateKey?: string;
    timeout?: number;
}
export interface PacketMetadata {
    timestamp: number;
    direction: "send" | "receive";
    size: number;
    type?: string;
}
export interface SSHClientCallbacks {
    onPacketSend?: (data: Uint8Array, metadata: PacketMetadata) => void;
    onPacketReceive?: (data: Uint8Array, metadata: PacketMetadata) => void;
    onStateChange?: (state: SSHConnectionState) => void;
}
export interface InitializationOptions {
    wasmPath?: string;
    wasmExecPath?: string;
    autoDetect?: boolean;
    publicDir?: string;
    cacheBusting?: boolean;
    timeout?: number;
}
export type SSHConnectionState = "connecting" | "connected" | "disconnecting" | "disconnected" | "error";
export interface SSHSession {
    sessionId: string;
    send: (data: Uint8Array) => Promise<void>;
    disconnect: () => Promise<void>;
    resizeTerminal: (cols: number, rows: number) => Promise<void>;
}
declare function detectFramework(): 'nextjs' | 'vite' | 'webpack' | 'generic';
declare function testAssetAvailability(wasmPath: string, wasmExecPath: string): Promise<{
    wasmAvailable: boolean;
    wasmExecAvailable: boolean;
}>;
export declare class SSHClient {
    private static wasmInstance;
    private static initialized;
    private static transportManager;
    static initialize(options?: InitializationOptions | string): Promise<void>;
    static connect(options: ConnectionOptions, transport: Transport, callbacks?: SSHClientCallbacks): Promise<SSHSession>;
    static disconnect(sessionId: string): Promise<void>;
    static send(sessionId: string, data: Uint8Array): Promise<void>;
    static getVersion(): string;
}
export declare class PacketTransformer {
    static toProtobuf(data: Uint8Array, schema?: any): Uint8Array;
    static fromProtobuf(data: Uint8Array, schema?: any): Uint8Array;
    static toBase64(data: Uint8Array): string;
    static fromBase64(base64: string): Uint8Array;
}
export declare const SSHClientHelpers: {
    /**
     * Get recommended asset paths for the detected framework
     */
    getAssetPaths: (publicDir?: string) => {
        wasmPath: string;
        wasmExecPath: string;
    };
    /**
     * Detect the current framework
     */
    detectFramework: typeof detectFramework;
    /**
     * Test if WASM assets are available at the given paths
     */
    testAssetAvailability: typeof testAssetAvailability;
    /**
     * Next.js specific initialization helper
     */
    initializeForNextJS: (options?: Partial<InitializationOptions>) => Promise<void>;
    /**
     * Vite specific initialization helper
     */
    initializeForVite: (options?: Partial<InitializationOptions>) => Promise<void>;
    /**
     * Generic initialization with sensible defaults
     */
    initializeWithDefaults: (customOptions?: Partial<InitializationOptions>) => Promise<void>;
};
export default SSHClient;
//# sourceMappingURL=index.d.ts.map