import { Observable } from "rxjs";
import { ServiceChecker, SpiderMesh } from "./SpiderMesh.js";
import { RpcOptions, SpiderMeshNode } from "./types.js";
export type IsUnknown<T, A, B> = unknown extends T ? ([T] extends [unknown] ? A : B) : B;
export type RemoteServiceOptions = Partial<RpcOptions<any>> & {
    service: string;
};
export type Unwrap<T> = Awaited<T> extends Observable<infer U> ? Observable<U> : (T extends Promise<infer V> ? Promise<V> : Promise<T>);
export type Fallbackable<Fn, FallbackValue = unknown> = Fn extends (...args: infer A) => infer R ? ((...args: A) => IsUnknown<FallbackValue, Unwrap<R>, FallbackValue | Unwrap<R>>) : undefined;
export type FunctionOnly<T, Fallback> = T extends (...args: any[]) => any ? Fallback : never;
export declare class RemoteServiceLinker<Service> {
    private sm;
    private options;
    constructor(sm: SpiderMesh, options: RemoteServiceOptions);
    watch(): Observable<import("./types.js").NodeRef[]>;
    get nodes(): import("./types.js").NodeRef[];
    set<Fallback>(options: Omit<Partial<RpcOptions<Fallback>>, 'service' | 'method' | 'args'>): Mapper<Service, Fallback>;
    wait(checker?: ServiceChecker, stop$?: Observable<any>): Promise<import("./types.js").NodeRef[] | null>;
    static link<Service, Fallback = never>(sm: SpiderMesh, options: RemoteServiceOptions): Mapper<Service, Fallback>;
}
export type Mapper<Service, Fallback = unknown> = RemoteServiceLinker<Service> & ({
    [K in keyof Service as FunctionOnly<Service[K], K>]: Fallbackable<Service[K], Fallback>;
} & {
    [key in keyof Service as FunctionOnly<Service[key], key extends string ? `__batch__${key}` : never>]: Service[key] extends ((...args: any) => any) ? ((...args: Parameters<Service[key]>) => Observable<{
        node: SpiderMeshNode;
        data: Awaited<ReturnType<Service[key]>>;
    } | {
        node: SpiderMeshNode;
        error: Error;
    }>) : never;
});
export type RemoteService<Service> = Mapper<Service>;