import { ConnectionType, SerializationType } from "../enums";
import type { Peer } from "../peer";
import { BaseConnection, ServerMessage, BaseConnectionOptions } from "./base";
export interface DataConnectionOptions extends BaseConnectionOptions {
    _payload?: DataConnectionOptions;
}
/**
 * Wraps a DataChannel between two Peers.
 */
export declare class DataConnection extends BaseConnection<DataConnectionOptions> {
    connectionId: string;
    private static readonly ID_PREFIX;
    private static readonly MAX_BUFFERED_AMOUNT;
    private __negotiator;
    private get _negotiator();
    readonly label: string;
    readonly serialization: SerializationType;
    readonly reliable: boolean;
    stringify: (data: unknown) => string;
    parse: <T>(data: string) => T;
    get type(): ConnectionType.Data;
    private _buffer;
    private _bufferSize;
    private _buffering;
    private _chunkedData;
    private _dc;
    private __encodingQueue;
    private get _encodingQueue();
    get dataChannel(): RTCDataChannel;
    get bufferSize(): number;
    constructor(peerId: string, provider: Peer, options: DataConnectionOptions);
    /** Called by the Negotiator when the DataChannel is ready. */
    initialize(dc: RTCDataChannel): void;
    private _configureDataChannel;
    private _handleDataMessage;
    private _handleChunk;
    /**
     * Exposed functionality for users.
     */
    /** Allows user to close connection. */
    close(): void;
    /** Allows user to send data. */
    send<T>(data: T, chunked?: boolean): void;
    private _bufferedSend;
    private _trySend;
    private _tryBuffer;
    private _sendChunks;
    handleMessage(message: ServerMessage): void;
}