import { M as MCPOptions } from '../types-CmbeEBKR.js';

/**
 * Arrow IPC over WebSocket transport implementation
 *
 * This file implements a client for the Arrow IPC protocol, allowing efficient
 * binary data transfer between client and server for large datasets.
 */

/**
 * RPC format used by MCP for JSON-RPC 2.0 style communication
 */
interface MCPRPC {
    jsonrpc: string;
    id?: string | number;
    method?: string;
    params?: any;
    result?: any;
    error?: {
        code: number;
        message: string;
        data?: any;
    };
}
/**
 * Arrow IPC message structure
 */
interface ArrowMessage extends MCPRPC {
    binaryData?: Uint8Array;
}
/**
 * Arrow IPC event handlers
 */
interface ArrowEventHandlers {
    onOpen?: (event: Event) => void;
    onMessage?: (message: ArrowMessage) => void;
    onBinaryMessage?: (buffer: ArrayBuffer) => void;
    onError?: (event: Event) => void;
    onClose?: (event: CloseEvent) => void;
    onStatusChange?: (status: ArrowConnectionStatus) => void;
}
/**
 * Arrow IPC connection status
 */
declare enum ArrowConnectionStatus {
    DISCONNECTED = 0,
    CONNECTING = 1,
    CONNECTED = 2,
    CLOSING = 3,
    ERROR = 4,
    RECONNECTING = 5
}
/**
 * Arrow query options
 */
interface ArrowQueryOptions {
    format?: 'arrow' | 'json';
    timeout?: number;
    maxRows?: number;
}
/**
 * Arrow stream consumer callback
 */
type ArrowStreamConsumer = (chunk: Uint8Array) => void;
/**
 * Arrow query result
 */
interface ArrowQueryResult {
    query: string;
    schema: any;
    rowCount: number;
    data?: ArrayBuffer;
    json?: any[];
}
/**
 * MCP Resource types
 */
interface MCPResource {
    uri: string;
    name: string;
    description?: string;
}
/**
 * MCP Resource content
 */
interface MCPResourceContent {
    uri: string;
    text: string;
    mimeType: string;
}
/**
 * MCP Tool schema
 */
interface MCPToolSchema {
    type: string;
    properties: Record<string, any>;
    required?: string[];
}
/**
 * MCP Tool definition
 */
interface MCPTool {
    id: string;
    name: string;
    description: string;
    schema: MCPToolSchema;
}
/**
 * Server capabilities
 */
interface MCPCapabilities {
    protocolVersion: string;
    capabilities: {
        prompts?: any;
        resources?: any;
        tools?: any;
        experimental?: any;
    };
    serverInfo: {
        name: string;
        version: string;
    };
}
/**
 * Arrow IPC client for efficient binary data transfer
 */
declare class MCPArrowClient {
    private ws;
    private baseUrl;
    private apiKey?;
    private token?;
    private tenantId?;
    private status;
    private handlers;
    private messageQueue;
    private pendingRequests;
    private defaultTimeout;
    private reconnectAttempts;
    private maxReconnectAttempts;
    private reconnectDelay;
    private autoReconnect;
    private connectionPath;
    private connectionRetryTimer;
    private manualClose;
    private lastConnectionTime;
    private nextMessageId;
    private streamTimeout?;
    private heartbeatInterval;
    private heartbeatTimer;
    private missedHeartbeats;
    private maxMissedHeartbeats;
    private lastHeartbeatResponse;
    /**
     * Event listener map for custom events
     */
    private eventListeners;
    /**
     * Add an event listener for a specific event type
     */
    private addEventListener;
    /**
     * Remove an event listener
     */
    private removeEventListener;
    /**
     * Trigger event handlers for a specific event
     */
    private triggerEvent;
    /**
     * Creates a new Arrow IPC client
     */
    constructor(options: MCPOptions & {
        autoReconnect?: boolean;
        maxReconnectAttempts?: number;
        streamTimeout?: number;
    });
    /**
     * Connect to the Arrow IPC WebSocket endpoint
     */
    connect(path?: string, handlers?: ArrowEventHandlers): void;
    /**
     * Update and notify about status changes
     */
    private setStatus;
    /**
     * Handle WebSocket open event
     */
    private handleOpen;
    /**
     * Start heartbeat mechanism to keep connection alive
     */
    private startHeartbeat;
    /**
     * Stop heartbeat mechanism
     */
    private stopHeartbeat;
    /**
     * Send a heartbeat ping
     */
    private sendHeartbeat;
    /**
     * Handle a WebSocket message event
     */
    private handleMessage;
    /**
     * Handle WebSocket error event
     */
    private handleError;
    /**
     * Handle WebSocket close event
     */
    private handleClose;
    /**
     * Handle connection error
     */
    private handleConnectionError;
    /**
     * Send a message over the WebSocket
     */
    private sendArrowMessage;
    /**
     * Encode a message to binary format
     */
    private encodeMessage;
    /**
     * Decode an Arrow IPC message from binary data
     */
    private decodeMessage;
    /**
     * Queue a message for later
     */
    private queueMessage;
    /**
     * Process the message queue
     */
    private processQueue;
    /**
     * Attempt to reconnect to the WebSocket
     */
    private attemptReconnect;
    /**
     * Generate a unique message ID
     */
    private generateMessageId;
    /**
     * Get server capabilities
     */
    getCapabilities(): Promise<MCPCapabilities>;
    /**
     * List available resources
     */
    listResources(): Promise<{
        resources: MCPResource[];
    }>;
    /**
     * Get a specific resource
     */
    getResource(uri: string): Promise<{
        contents: MCPResourceContent[];
    }>;
    /**
     * List available tools
     */
    listTools(): Promise<{
        tools: MCPTool[];
    }>;
    /**
     * Get the current connection status
     */
    getStatus(): ArrowConnectionStatus;
    /**
     * Disconnect from the WebSocket
     */
    disconnect(): void;
    /**
     * Send a request to a model (like Claude) through the MCP server
     */
    sendRequest(options: {
        path: string;
        method?: 'GET' | 'POST' | 'PUT' | 'DELETE';
        body?: any;
        responseType?: 'json' | 'arrow';
        metrics?: boolean;
        onChunk?: (chunk: any) => void;
    }): Promise<{
        data: any;
        status: number;
        headers: Record<string, string>;
        metrics?: {
            totalTime: number;
            serializationTime: number;
            networkTime: number;
            deserializationTime: number;
        };
    }>;
    /**
     * Check server health
     */
    checkHealth(): Promise<boolean>;
    /**
     * Get server connection status as string
     */
    getConnectionStatusText(): string;
    /**
     * Process an incoming message
     */
    private processMessage;
}
/**
 * Create an Arrow IPC client
 */
declare function createArrowClient(options: MCPOptions): MCPArrowClient;

export { ArrowConnectionStatus, type ArrowEventHandlers, type ArrowMessage, type ArrowQueryOptions, type ArrowQueryResult, type ArrowStreamConsumer, MCPArrowClient, type MCPCapabilities, type MCPRPC, type MCPResource, type MCPResourceContent, type MCPTool, type MCPToolSchema, createArrowClient, MCPArrowClient as default };