import { BinaryReader, BinaryWriter } from "./binary";
import type { HugeIntLike, HugeIntParts } from "./binary";
import type { LogicalType } from "./logical-types";
import type { QuackDataChunk } from "./vector";
/** Quack protocol message type ids. */
export declare enum MessageType {
    INVALID = 0,
    CONNECTION_REQUEST = 1,
    CONNECTION_RESPONSE = 2,
    PREPARE_REQUEST = 3,
    PREPARE_RESPONSE = 4,
    FETCH_REQUEST = 7,
    FETCH_RESPONSE = 8,
    APPEND_REQUEST = 9,
    SUCCESS_RESPONSE = 10,
    DISCONNECT_MESSAGE = 11,
    ERROR_RESPONSE = 100
}
/** Fields shared by every Quack protocol message header. */
export interface MessageHeader {
    /** Message type id. */
    type: MessageType;
    /** Server-assigned connection id for connection-scoped messages. */
    connectionId?: string;
    /** Client-assigned query/request id. */
    clientQueryId?: bigint;
}
/** Base type for a concrete Quack protocol message. */
export interface BaseMessage<T extends MessageType> extends MessageHeader {
    /** Concrete message type id. */
    type: T;
}
/** Request sent by a client to open a Quack connection. */
export interface ConnectionRequestMessage extends BaseMessage<MessageType.CONNECTION_REQUEST> {
    /** Optional authentication token. */
    authString?: string;
    /** Optional client DuckDB version. */
    clientDuckdbVersion?: string;
    /** Optional client platform string. */
    clientPlatform?: string;
    /** Minimum supported Quack protocol version. */
    minSupportedQuackVersion?: number | bigint;
    /** Maximum supported Quack protocol version. */
    maxSupportedQuackVersion?: number | bigint;
}
/** Response returned by a server after opening a Quack connection. */
export interface ConnectionResponseMessage extends BaseMessage<MessageType.CONNECTION_RESPONSE> {
    /** Server DuckDB version string. */
    serverDuckdbVersion?: string;
    /** Server platform string. */
    serverPlatform?: string;
    /** Negotiated/reported Quack protocol version. */
    quackVersion?: bigint;
}
/** Request to prepare and execute SQL. */
export interface PrepareRequestMessage extends BaseMessage<MessageType.PREPARE_REQUEST> {
    /** SQL text to execute. */
    sql: string;
}
/** Response containing result schema, initial chunks, and fetch state. */
export interface PrepareResponseMessage extends BaseMessage<MessageType.PREPARE_RESPONSE> {
    /** Logical types for result columns. */
    resultTypes: LogicalType[];
    /** Result column names. */
    resultNames: string[];
    /** Whether more result chunks can be fetched. */
    needsMoreFetch: boolean;
    /** Initial result chunks. */
    results: QuackDataChunk[];
    /** Server-side result id for subsequent fetch requests. */
    resultUuid: HugeIntParts;
}
/** Request to fetch additional chunks for a previous result. */
export interface FetchRequestMessage extends BaseMessage<MessageType.FETCH_REQUEST> {
    /** Result id returned by a prepare response. */
    resultUuid: HugeIntLike;
}
/** Response containing additional result chunks. */
export interface FetchResponseMessage extends BaseMessage<MessageType.FETCH_RESPONSE> {
    /** Fetched result chunks. */
    results: QuackDataChunk[];
    /** Optional server batch index. */
    batchIndex?: bigint;
}
/** Request to append a DataChunk into a DuckDB table. */
export interface AppendRequestMessage extends BaseMessage<MessageType.APPEND_REQUEST> {
    /** Optional schema name. */
    schemaName?: string;
    /** Target table name. */
    tableName: string;
    /** DataChunk to append. */
    appendChunk: QuackDataChunk;
}
/** Generic success response. */
export interface SuccessResponseMessage extends BaseMessage<MessageType.SUCCESS_RESPONSE> {
}
/** Message requesting that the server close the connection. */
export interface DisconnectMessage extends BaseMessage<MessageType.DISCONNECT_MESSAGE> {
}
/** Server error response. */
export interface ErrorResponseMessage extends BaseMessage<MessageType.ERROR_RESPONSE> {
    /** Server-provided error message. */
    message: string;
}
/** Union of all Quack protocol messages supported by this SDK. */
export type QuackMessage = ConnectionRequestMessage | ConnectionResponseMessage | PrepareRequestMessage | PrepareResponseMessage | FetchRequestMessage | FetchResponseMessage | AppendRequestMessage | SuccessResponseMessage | DisconnectMessage | ErrorResponseMessage;
/** Encode a Quack protocol message into its binary wire representation. */
export declare function encodeMessage(message: QuackMessage): Uint8Array;
/** Decode a Quack protocol message from its binary wire representation. */
export declare function decodeMessage(bytes: Uint8Array): QuackMessage;
/** Encode a Quack message header. */
export declare function encodeHeader(writer: BinaryWriter, header: MessageHeader): void;
/** Decode a Quack message header. */
export declare function decodeHeader(reader: BinaryReader): MessageHeader;