import { type AbstractType } from "@dao-xyz/borsh";
import { PublicSignKey } from "@peerbit/crypto";
import { Program, type ProgramEvents } from "@peerbit/program";
import { DataMessage, type RequestTransportContext } from "@peerbit/stream-interface";
import { type RPCRequestOptions, type RPCResponse, type RPCSendOptions } from "./io.js";
export type RPCSetupOptions<Q, R> = {
    topic: string;
    queryType: AbstractType<Q>;
    responseType: AbstractType<R>;
    responseHandler?: ResponseHandler<Q, R>;
    /**
     * Opt-in fast path: resolve the request object for an inbound message
     * without decoding `RequestV0.request` (e.g. from a native wire stash
     * keyed by the message id). Returning undefined falls back to the normal
     * decrypt + deserialize path, so semantics never diverge.
     */
    resolveRequest?: (message: DataMessage) => Q | undefined;
};
export type RequestContext = {
    from?: PublicSignKey;
    message: DataMessage;
    transport: RequestTransportContext;
};
export type ResponseHandler<Q, R> = (query: Q, context: RequestContext) => Promise<R | undefined> | R | undefined;
export type ResponseEvent<R> = {
    response: R;
    message: DataMessage;
    from?: PublicSignKey;
};
export type RequestEvent<R> = {
    request: R;
    message: DataMessage;
    from?: PublicSignKey;
};
export type CodecErrorEvent = {
    error: Error;
    stage: "decode-request" | "handle-request" | "encode-response" | "publish-response" | "dispatch-response" | "decode-response";
    message: DataMessage;
};
export interface RPCEvents<Q, R> extends ProgramEvents {
    request: CustomEvent<RequestEvent<Q>>;
    response: CustomEvent<ResponseEvent<R>>;
    codecError: CustomEvent<CodecErrorEvent>;
}
export declare class RPC<Q, R> extends Program<RPCSetupOptions<Q, R>, RPCEvents<Q, R>> {
    private _subscribed;
    private _responseHandler?;
    private _resolveRequest?;
    private _responseResolver;
    private _requestType;
    private _requestTypeIsUint8Array;
    private _responseType;
    private _rpcTopic;
    private _onMessageBinded;
    private _listenerAttached;
    private _keypair;
    private _getResponseValueFn;
    private _getRequestValueFn;
    open(args: RPCSetupOptions<Q, R>): Promise<void>;
    private _close;
    close(from?: Program): Promise<boolean>;
    drop(from?: Program): Promise<boolean>;
    private _subscribing;
    subscribe(): Promise<void>;
    private _onMessage;
    private seal;
    private getPublishOptions;
    /**
     * Send message and don't expect any response
     * @param message
     * @param options
     */
    send(message: Q, options?: RPCSendOptions): Promise<void>;
    private handleDecodedResponse;
    private createResponseHandler;
    /**
     * Send a request and expect a response
     * @param request
     * @param options
     * @returns
     */
    request(request: Q, options?: RPCRequestOptions<R>): Promise<RPCResponse<R>[]>;
    get topic(): string;
    getTopics(): string[];
}
//# sourceMappingURL=controller.d.ts.map