import z$1, { z } from 'zod';
import { ChannelOptions } from 'nice-grpc';

type Context<Meta extends z.ZodObject<any> | undefined> = {
    metadata: Meta extends z.ZodObject<any> ? z.infer<Meta> : undefined;
    client: {
        id: string;
    };
};
type AnyContext = Context<any>;

declare const ScopeTag: unique symbol;
declare const FunctionTag: unique symbol;
declare const ContextTag: unique symbol;
type BaseSignature<type extends "server" | "client" | "bidi", fn extends (...args: any[]) => any, C extends AnyContext | undefined> = {
    [ScopeTag]: type;
    [FunctionTag]: fn;
    [ContextTag]: type extends "server" ? (C extends undefined ? Context<undefined> : C) : C;
};
type AnyBaseSignature = BaseSignature<any, any, any>;
type ExtractFn<S extends AnyBaseSignature> = (...args: Parameters<S[typeof FunctionTag]>) => Promise<ReturnType<S[typeof FunctionTag]>>;
type ValidReturnType<fn extends (...args: any[]) => any> = ReturnType<fn> extends Function | Promise<any> ? never : ReturnType<fn>;
type ExtractImplFn<S extends AnyBaseSignature> = S[typeof ScopeTag] extends "server" ? ExtractFn<S> | ((...args: Parameters<S[typeof FunctionTag]>) => (context: S[typeof ContextTag]) => Promise<ReturnType<S[typeof FunctionTag]>>) : S[typeof ScopeTag] extends "client" ? ExtractFn<S> : S[typeof ScopeTag] extends "bidi" ? undefined : never;
type RpcMethodDescriptor = {
    serviceType: "server" | "client" | "bidi";
    methodType: "unary" | "bidi";
    config?: {
        metadata: boolean;
        ack: boolean;
    };
};

type BidiSignature<fn extends (...args: any[]) => any, C extends AnyContext | undefined> = BaseSignature<"bidi", fn, C> & (C extends undefined ? <Meta extends z$1.ZodObject<any>>(context: {
    metadata?: Meta;
    ack?: boolean;
}) => BidiSignature<fn, Context<Meta>> : {});
declare function bidi<fn extends (...args: any[]) => ValidReturnType<fn>>(): BidiSignature<fn, undefined>;

type ClientSignature<fn extends (...args: any[]) => any, C extends AnyContext | undefined> = BaseSignature<"client", fn, C>;
declare function client<fn extends (...args: any[]) => ValidReturnType<fn>>(): ClientSignature<fn, undefined>;
type ClientImpls<T> = {
    [K in keyof T as T[K] extends BaseSignature<"client", any, any> ? K : never]: T[K] extends AnyBaseSignature ? ExtractImplFn<T[K]> : never;
};
type ClientCallable<T, WithListen extends boolean = true> = {
    [K in keyof T as T[K] extends BaseSignature<"client", any, any> | BaseSignature<"bidi", any, any> ? K : never]: T[K] extends BaseSignature<"client", any, any> ? ExtractFn<T[K]> : T[K] extends BaseSignature<"bidi", any, infer C> ? WithListen extends true ? BidiCallable$1<T[K], C> : BidiCallableWithoutListen<T[K], C> : never;
};
type BidiContext<C extends AnyContext | undefined> = C extends undefined ? Context<undefined> : C;
type BidiCallableBase<S extends BaseSignature<"bidi", any, any>, C extends AnyContext | undefined> = ExtractFn<S> & {
    context: BidiContext<C>;
} & AsyncGenerator<Parameters<ExtractFn<S>>, void, unknown>;
type BidiCallable$1<S extends BaseSignature<"bidi", any, any>, C extends AnyContext | undefined> = BidiCallableBase<S, C> & {
    listen(handler: (connection: {
        context: BidiContext<C>;
        messages: AsyncGenerator<Parameters<ExtractFn<S>>, void, unknown>;
        send: ExtractFn<S>;
    }) => void): void;
};
type BidiCallableWithoutListen<S extends BaseSignature<"bidi", any, any>, C extends AnyContext | undefined> = BidiCallableBase<S, C>;

type ServerSignature<fn extends (...args: any[]) => any, C extends AnyContext | undefined> = BaseSignature<"server", fn, C> & (C extends undefined ? <Meta extends z$1.ZodObject<any>>(context: {
    metadata: Meta;
}) => ServerSignature<fn, Context<Meta>> : {});
declare function server<fn extends (...args: any[]) => ValidReturnType<fn>>(): ServerSignature<fn, undefined>;
type ServerImpls<T> = {
    [K in keyof T as T[K] extends BaseSignature<"server", any, any> ? K : never]: T[K] extends AnyBaseSignature ? ExtractImplFn<T[K]> : never;
};
type ServerCallable<T> = {
    [K in keyof T as T[K] extends BaseSignature<"server", any, any> | BaseSignature<"bidi", any, any> ? K : never]: T[K] extends BaseSignature<"server", any, infer C> ? (...args: Parameters<ExtractFn<T[K]>>) => CallableChain<ExtractFn<T[K]>, C> : T[K] extends BaseSignature<"bidi", any, infer C> ? BidiCallable<T[K], C> : never;
};
type CallableChain<fn extends (...args: any[]) => any, C extends AnyContext | undefined> = C extends Context<infer Meta> ? Meta extends z$1.ZodObject<any> ? {
    withMeta(meta: z$1.infer<Meta>): ReturnType<fn>;
} : ReturnType<fn> : ReturnType<fn>;
type BidiCallable<S extends BaseSignature<"bidi", any, any>, C extends AnyContext | undefined> = (C extends Context<infer Meta> ? Meta extends z$1.ZodObject<any> ? {
    context(context: {
        metadata: z$1.infer<Meta>;
    }): Promise<void>;
} & ExtractFn<S> : ExtractFn<S> : ExtractFn<S>) & AsyncGenerator<Parameters<ExtractFn<S>>, void, unknown>;

declare const ServiceNameTag: unique symbol;
interface ServiceInstance<N extends string = string> {
    readonly [ServiceNameTag]: N;
}
type AbstractServiceClass<N extends string = string> = abstract new (...args: never) => ServiceInstance<N>;
declare class ServiceImpl<T extends AbstractServiceClass, Type extends "server" | "client"> {
    readonly implementation: any;
    readonly type: Type;
    readonly serviceClass: T;
    readonly serviceClassInstance: InstanceType<T>;
    constructor(implementation: any, type: Type, serviceClass: T);
    methods(): Record<string, RpcMethodDescriptor>;
}
declare function Service<N extends string>(name: N): (abstract new () => {
    readonly [ServiceNameTag]: N;
}) & {
    serviceName: N;
    Server<T extends AbstractServiceClass, Impl extends ServerImpls<InstanceType<T>>>(this: T, implementation: Impl): ServiceImpl<T, "server">;
    Client<T extends AbstractServiceClass, Impl extends ClientImpls<InstanceType<T>>>(this: T, implementation: Impl): ServiceImpl<T, "client">;
};
type ServiceNameOf<T extends ServiceImpl<any, any>> = T extends ServiceImpl<infer ServiceClass, any> ? InstanceType<ServiceClass>[typeof ServiceNameTag] : never;
type ServiceCallable<T, WithListen extends boolean = true> = T extends ServiceImpl<infer S, infer Mode> ? Mode extends "server" ? ClientCallable<InstanceType<S>, WithListen> : ServerCallable<InstanceType<S>> : never;

declare const DEFAULT_OPTIONS: ChannelOptions;
declare function createGrpcClient<T extends ServiceImpl<any, "client">[]>(address: string, credentials: "ssl" | "insecure", ...serviceImpls: T): Promise<{
    [I in T[number] as ServiceNameOf<I>]: ServiceCallable<I>;
} & {
    clientID: string;
}>;
declare function createGrpcClient<T extends ServiceImpl<any, "client">[]>(address: string, credentials: "ssl" | "insecure", grpcOptions: ChannelOptions, ...serviceImpls: T): Promise<{
    [I in T[number] as ServiceNameOf<I>]: ServiceCallable<I>;
} & {
    clientID: string;
}>;
declare function createGrpcClient<T extends ServiceImpl<any, "client">[]>(address: string, ...serviceImpls: T): Promise<{
    [I in T[number] as ServiceNameOf<I>]: ServiceCallable<I>;
} & {
    clientID: string;
}>;
declare function createGrpcClient<T extends ServiceImpl<any, "client">[]>(address: string, grpcOptions: ChannelOptions, ...serviceImpls: T): Promise<{
    [I in T[number] as ServiceNameOf<I>]: ServiceCallable<I>;
} & {
    clientID: string;
}>;

declare function createGrpcServer<T extends ServiceImpl<any, "server">[]>(port: number, ...serviceImpls: T): Promise<{
    [I in T[number] as ServiceNameOf<I>]: ServiceCallable<I> & ((clientId: string) => ServiceCallable<I, false>);
}>;

export { DEFAULT_OPTIONS, Service, bidi, client, createGrpcClient, createGrpcServer, server };