import type { Codec, DecodeOptions } from 'protons-runtime';
import type { Uint8ArrayList } from 'uint8arraylist';
export interface RPC {
    subscriptions: RPC.SubOpts[];
    messages: RPC.Message[];
    control?: ControlMessage;
}
export declare namespace RPC {
    interface SubOpts {
        subscribe?: boolean;
        topic?: string;
    }
    namespace SubOpts {
        const codec: () => Codec<SubOpts>;
        interface SubOptsSubscribeFieldEvent {
            field: '$.subscribe';
            value: boolean;
        }
        interface SubOptsTopicFieldEvent {
            field: '$.topic';
            value: string;
        }
        function encode(obj: Partial<SubOpts>): Uint8Array;
        function decode(buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<SubOpts>): SubOpts;
        function stream(buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<SubOpts>): Generator<SubOptsSubscribeFieldEvent | SubOptsTopicFieldEvent>;
    }
    interface Message {
        from?: Uint8Array;
        data?: Uint8Array;
        sequenceNumber?: Uint8Array;
        topic?: string;
        signature?: Uint8Array;
        key?: Uint8Array;
    }
    namespace Message {
        const codec: () => Codec<Message>;
        interface MessageFromFieldEvent {
            field: '$.from';
            value: Uint8Array;
        }
        interface MessageDataFieldEvent {
            field: '$.data';
            value: Uint8Array;
        }
        interface MessageSequenceNumberFieldEvent {
            field: '$.sequenceNumber';
            value: Uint8Array;
        }
        interface MessageTopicFieldEvent {
            field: '$.topic';
            value: string;
        }
        interface MessageSignatureFieldEvent {
            field: '$.signature';
            value: Uint8Array;
        }
        interface MessageKeyFieldEvent {
            field: '$.key';
            value: Uint8Array;
        }
        function encode(obj: Partial<Message>): Uint8Array;
        function decode(buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<Message>): Message;
        function stream(buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<Message>): Generator<MessageFromFieldEvent | MessageDataFieldEvent | MessageSequenceNumberFieldEvent | MessageTopicFieldEvent | MessageSignatureFieldEvent | MessageKeyFieldEvent>;
    }
    const codec: () => Codec<RPC>;
    interface RPCSubscriptionsSubscribeFieldEvent {
        field: '$.subscriptions[].subscribe';
        value: boolean;
        index: number;
    }
    interface RPCSubscriptionsTopicFieldEvent {
        field: '$.subscriptions[].topic';
        value: string;
        index: number;
    }
    interface RPCMessagesFromFieldEvent {
        field: '$.messages[].from';
        value: Uint8Array;
        index: number;
    }
    interface RPCMessagesDataFieldEvent {
        field: '$.messages[].data';
        value: Uint8Array;
        index: number;
    }
    interface RPCMessagesSequenceNumberFieldEvent {
        field: '$.messages[].sequenceNumber';
        value: Uint8Array;
        index: number;
    }
    interface RPCMessagesTopicFieldEvent {
        field: '$.messages[].topic';
        value: string;
        index: number;
    }
    interface RPCMessagesSignatureFieldEvent {
        field: '$.messages[].signature';
        value: Uint8Array;
        index: number;
    }
    interface RPCMessagesKeyFieldEvent {
        field: '$.messages[].key';
        value: Uint8Array;
        index: number;
    }
    interface RPCControlIhaveTopicFieldEvent {
        field: '$.control.ihave[].topic';
        value: string;
        index: number;
    }
    interface RPCControlIhaveMessageIDsFieldEvent {
        field: '$.control.ihave[].messageIDs[]';
        index: number;
        value: Uint8Array;
    }
    interface RPCControlIwantMessageIDsFieldEvent {
        field: '$.control.iwant[].messageIDs[]';
        index: number;
        value: Uint8Array;
    }
    interface RPCControlGraftTopicFieldEvent {
        field: '$.control.graft[].topic';
        value: string;
        index: number;
    }
    interface RPCControlPruneTopicFieldEvent {
        field: '$.control.prune[].topic';
        value: string;
        index: number;
    }
    interface RPCControlPrunePeersPeerIDFieldEvent {
        field: '$.control.prune[].peers[].peerID';
        value: Uint8Array;
        index: number;
    }
    interface RPCControlPrunePeersSignedPeerRecordFieldEvent {
        field: '$.control.prune[].peers[].signedPeerRecord';
        value: Uint8Array;
        index: number;
    }
    interface RPCControlPruneBackoffFieldEvent {
        field: '$.control.prune[].backoff';
        value: bigint;
        index: number;
    }
    function encode(obj: Partial<RPC>): Uint8Array;
    function decode(buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<RPC>): RPC;
    function stream(buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<RPC>): Generator<RPCSubscriptionsSubscribeFieldEvent | RPCSubscriptionsTopicFieldEvent | RPCMessagesFromFieldEvent | RPCMessagesDataFieldEvent | RPCMessagesSequenceNumberFieldEvent | RPCMessagesTopicFieldEvent | RPCMessagesSignatureFieldEvent | RPCMessagesKeyFieldEvent | RPCControlIhaveTopicFieldEvent | RPCControlIhaveMessageIDsFieldEvent | RPCControlIwantMessageIDsFieldEvent | RPCControlGraftTopicFieldEvent | RPCControlPruneTopicFieldEvent | RPCControlPrunePeersPeerIDFieldEvent | RPCControlPrunePeersSignedPeerRecordFieldEvent | RPCControlPruneBackoffFieldEvent>;
}
export interface ControlMessage {
    ihave: ControlIHave[];
    iwant: ControlIWant[];
    graft: ControlGraft[];
    prune: ControlPrune[];
}
export declare namespace ControlMessage {
    const codec: () => Codec<ControlMessage>;
    interface ControlMessageIhaveTopicFieldEvent {
        field: '$.ihave[].topic';
        value: string;
        index: number;
    }
    interface ControlMessageIhaveMessageIDsFieldEvent {
        field: '$.ihave[].messageIDs[]';
        index: number;
        value: Uint8Array;
    }
    interface ControlMessageIwantMessageIDsFieldEvent {
        field: '$.iwant[].messageIDs[]';
        index: number;
        value: Uint8Array;
    }
    interface ControlMessageGraftTopicFieldEvent {
        field: '$.graft[].topic';
        value: string;
        index: number;
    }
    interface ControlMessagePruneTopicFieldEvent {
        field: '$.prune[].topic';
        value: string;
        index: number;
    }
    interface ControlMessagePrunePeersPeerIDFieldEvent {
        field: '$.prune[].peers[].peerID';
        value: Uint8Array;
        index: number;
    }
    interface ControlMessagePrunePeersSignedPeerRecordFieldEvent {
        field: '$.prune[].peers[].signedPeerRecord';
        value: Uint8Array;
        index: number;
    }
    interface ControlMessagePruneBackoffFieldEvent {
        field: '$.prune[].backoff';
        value: bigint;
        index: number;
    }
    function encode(obj: Partial<ControlMessage>): Uint8Array;
    function decode(buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<ControlMessage>): ControlMessage;
    function stream(buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<ControlMessage>): Generator<ControlMessageIhaveTopicFieldEvent | ControlMessageIhaveMessageIDsFieldEvent | ControlMessageIwantMessageIDsFieldEvent | ControlMessageGraftTopicFieldEvent | ControlMessagePruneTopicFieldEvent | ControlMessagePrunePeersPeerIDFieldEvent | ControlMessagePrunePeersSignedPeerRecordFieldEvent | ControlMessagePruneBackoffFieldEvent>;
}
export interface ControlIHave {
    topic?: string;
    messageIDs: Uint8Array[];
}
export declare namespace ControlIHave {
    const codec: () => Codec<ControlIHave>;
    interface ControlIHaveTopicFieldEvent {
        field: '$.topic';
        value: string;
    }
    interface ControlIHaveMessageIDsFieldEvent {
        field: '$.messageIDs[]';
        index: number;
        value: Uint8Array;
    }
    function encode(obj: Partial<ControlIHave>): Uint8Array;
    function decode(buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<ControlIHave>): ControlIHave;
    function stream(buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<ControlIHave>): Generator<ControlIHaveTopicFieldEvent | ControlIHaveMessageIDsFieldEvent>;
}
export interface ControlIWant {
    messageIDs: Uint8Array[];
}
export declare namespace ControlIWant {
    const codec: () => Codec<ControlIWant>;
    interface ControlIWantMessageIDsFieldEvent {
        field: '$.messageIDs[]';
        index: number;
        value: Uint8Array;
    }
    function encode(obj: Partial<ControlIWant>): Uint8Array;
    function decode(buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<ControlIWant>): ControlIWant;
    function stream(buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<ControlIWant>): Generator<ControlIWantMessageIDsFieldEvent>;
}
export interface ControlGraft {
    topic?: string;
}
export declare namespace ControlGraft {
    const codec: () => Codec<ControlGraft>;
    interface ControlGraftTopicFieldEvent {
        field: '$.topic';
        value: string;
    }
    function encode(obj: Partial<ControlGraft>): Uint8Array;
    function decode(buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<ControlGraft>): ControlGraft;
    function stream(buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<ControlGraft>): Generator<ControlGraftTopicFieldEvent>;
}
export interface ControlPrune {
    topic?: string;
    peers: PeerInfo[];
    backoff?: bigint;
}
export declare namespace ControlPrune {
    const codec: () => Codec<ControlPrune>;
    interface ControlPruneTopicFieldEvent {
        field: '$.topic';
        value: string;
    }
    interface ControlPrunePeersPeerIDFieldEvent {
        field: '$.peers[].peerID';
        value: Uint8Array;
        index: number;
    }
    interface ControlPrunePeersSignedPeerRecordFieldEvent {
        field: '$.peers[].signedPeerRecord';
        value: Uint8Array;
        index: number;
    }
    interface ControlPruneBackoffFieldEvent {
        field: '$.backoff';
        value: bigint;
    }
    function encode(obj: Partial<ControlPrune>): Uint8Array;
    function decode(buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<ControlPrune>): ControlPrune;
    function stream(buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<ControlPrune>): Generator<ControlPruneTopicFieldEvent | ControlPrunePeersPeerIDFieldEvent | ControlPrunePeersSignedPeerRecordFieldEvent | ControlPruneBackoffFieldEvent>;
}
export interface PeerInfo {
    peerID?: Uint8Array;
    signedPeerRecord?: Uint8Array;
}
export declare namespace PeerInfo {
    const codec: () => Codec<PeerInfo>;
    interface PeerInfoPeerIDFieldEvent {
        field: '$.peerID';
        value: Uint8Array;
    }
    interface PeerInfoSignedPeerRecordFieldEvent {
        field: '$.signedPeerRecord';
        value: Uint8Array;
    }
    function encode(obj: Partial<PeerInfo>): Uint8Array;
    function decode(buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<PeerInfo>): PeerInfo;
    function stream(buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<PeerInfo>): Generator<PeerInfoPeerIDFieldEvent | PeerInfoSignedPeerRecordFieldEvent>;
}
//# sourceMappingURL=rpc.d.ts.map