import type { ConnectionOptions } from "nats";
import { type DefaultClient } from "./ServiceClient";
import type { ServiceMessage } from "./ServiceMessage";
import { type HandlerStatsReport, type Stats } from "./ServiceStats";
export interface ServiceInstanceInfo {
    origin: string;
    domain: string | null;
}
export interface ServiceApi<D extends string> {
    domain: D;
    handlers: {
        [name: string]: (arg: never) => Promise<unknown | AsyncIterableIterator<unknown>>;
    };
}
export interface ServiceConfig<T extends ServiceApi<D>, D extends string = T["domain"]> {
    nats?: ConnectionOptions & {
        monitorUrl?: string;
    };
    signSalt?: string;
    responseTimeout?: number;
    handlers?: {
        [H in keyof T["handlers"]]: Handler<T, H, D>;
    };
    timeLogFilter?: (method: keyof (T["handlers"] & Omit<DefaultClient, "stats" | "isConnected">)) => "none" | "compact" | "full";
    isHandlerAvailable?: (method: keyof T["handlers"]) => boolean;
}
export type Handler<T extends ServiceApi<D>, H extends keyof T["handlers"], D extends string = T["domain"]> = (arg: Parameters<T["handlers"][H]>[0], service: Service<T>) => ReturnType<T["handlers"][H]>;
declare class Service<T extends ServiceApi<D>, D extends string = T["domain"]> {
    readonly origin: string;
    private isClientOnly;
    private log;
    private readonly serviceStats;
    private readonly clientStats;
    readonly domain: D;
    private readonly config;
    private transport;
    private connection;
    private readonly handlers;
    private connected;
    private timeLogFilter;
    constructor(domain: D, config?: ServiceConfig<T>);
    get isConnected(): boolean;
    get stats(): {
        origin: string;
        domain: string | null;
        service: Record<string, HandlerStatsReport>;
        client: Record<string, HandlerStatsReport>;
    };
    getPeers(): Promise<ServiceInstanceInfo[]>;
    getPeerStats(): Promise<Stats[]>;
    private getConnection;
    connect(): Promise<void>;
    disconnect(): Promise<void>;
    /**
     * Returns the total time to fulfill a simple request from the client's perspective. This
     * round trip entails 4 message transfers:
     *
     *    client -> NATS (request)
     *    NATS -> service (request)
     *    -------------------------
     *    service -> NATS (response)
     *    NATS -> client (response)
     *
     * @returns the latency in milliseconds
     */
    testLatency(): Promise<number>;
    protected marshalPayload(payload: ServiceMessage): ServiceMessage;
    protected unmarshalPayload(payload: ServiceMessage): ServiceMessage;
    /**
     *
     * @param domain
     * @returns
     */
    getClient(): T["handlers"] & DefaultClient;
    private handleRequest;
}
export default Service;