import { grpc, type ChannelOptions } from '../../../deps/grpc';
import { type IPolicy } from '../../../deps/cockatiel';
import type { IOptions, CallOptionsFactory } from '../../base/options';
import type { Services, CallMethod, CallService } from '../../api/rpc';
import type IDriver from '../i-driver';
export declare class Host {
    private readonly channelCredentials;
    private readonly channelOptions?;
    readonly faultHandling: IPolicy;
    private readonly host;
    private closed;
    private cachedServices;
    constructor(host: string, channelCredentials: grpc.ChannelCredentials, channelOptions?: ChannelOptions | undefined, faultHandling?: IPolicy);
    getServiceClient(name: keyof typeof Services): grpc.Client;
    resetAllServices(): void;
    close(): void;
}
export declare class ETCDDriver implements IDriver {
    static deterministicOrder: boolean;
    readonly callOptionsFactory: CallOptionsFactory | undefined;
    private readonly hosts;
    private readonly globalPolicy;
    private readonly options;
    constructor(opt: IOptions);
    init(options: any): Promise<void>;
    close(): void;
    exec<T>(serviceName: CallService, method: CallMethod, payload: unknown, options?: grpc.CallOptions): Promise<T>;
    withConnection<T>(service: keyof typeof Services, fn: (args: {
        resource: Host;
        client: grpc.Client;
    }) => Promise<T> | T, shuffleGenerator?: Generator<Host, void, unknown>): Promise<T>;
    markFailed(resource: Host, error: Error): void;
    private shuffledHosts;
}