import { SocketDescriptor } from './socket';
import { Packet } from './packet';
import { Signal, SignalReceiverCastResult } from './signal';
import { Socket } from './socket-base';
import { MimetypePrefix } from './payload-description';
export declare class OutputSocket extends Socket {
    static fromUnsafe(s: Socket): OutputSocket;
    private peers_;
    constructor(descriptor: SocketDescriptor);
    close(): void;
    transferSync(p: Packet): boolean;
    /**
     * {Socket} Another socket to which this socket transfers data ownership to.
     */
    connect(s: Socket): OutputSocket;
    /**
     * Disconnects this socket from peer socket s (which this had previously connected with `connect` method)
     * If `null` or default is passed, all peer sockets are disconnected.
     * If socket passed is not a peer socket, will throw an error.
     * @param s
     */
    disconnect(s?: Socket): OutputSocket;
    isConnectedTo(s: Socket): boolean;
    getPeerSockets(): Socket[];
    getNumberOfPeers(): number;
    hasPeers(): boolean;
    /**
     * Cast a signal from this socket.
     *
     * When signal travels down, broadcast to all peer sockets.
     *
     * All other cases (zero or up direction), broadcast to owner.
     *
     * Also calls the super-class implementation and collects results together.
     */
    cast(signal: Signal): SignalReceiverCastResult;
    /**
     * Handler set on all peer sockets, called when they cast a signal.
     *
     * When the signal is up, we cast it to our socket owner.
     *
     * When it travels down, we don't need to do anything and return a
     * negative result (since we did not handle the signal)
     *
     */
    private _onPeerSignalCast;
    private onPacketTransferred_;
    private onPacketTransferredToPeerInput_;
    private onPacketTransferredToPeerOutput_;
}
export declare class ShadowOutputSocket extends OutputSocket {
    constructor(payloadShadowTypes: MimetypePrefix[], streamId?: number);
}