RpcGroup

interface Any {
  readonly [TypeId]: typeof TypeId;
}

type HandlerContext<Rpcs extends Rpc.Any, K extends Rpcs["_tag"], Handler> = [Rpc.IsStream<Rpcs, K>] extends [true] ? Handler extends (...args: any) => Stream.Stream<infer _A, infer _E, infer _R> | Rpc.Wrapper<Stream.Stream<infer _A, infer _E, infer _R>> | Effect.Effect<ReadonlyMailbox<infer _A, infer _E>, infer _EX, infer _R> | Rpc.Wrapper<Effect.Effect<ReadonlyMailbox<infer _A, infer _E>, infer _EX, infer _R>> ? Exclude<Rpc.ExcludeProvides<_R, Rpcs, K>, Scope> : never : Handler extends (...args: any) => Effect.Effect<infer _A, infer _E, infer _R> | Rpc.Wrapper<Effect.Effect<infer _A, infer _E, infer _R>> ? Rpc.ExcludeProvides<_R, Rpcs, K> : never

type HandlerFrom<Rpc extends Rpc.Any, Tag extends Rpc["_tag"]> = Extract<Rpc, {
  readonly _tag: Tag;
}> extends infer Current ? Current extends Rpc.Any ? Rpc.ToHandlerFn<Current> : never : never

type HandlersContext<Rpcs extends Rpc.Any, Handlers> = keyof Handlers extends infer K ? K extends keyof Handlers & string ? HandlerContext<Rpcs, K, Handlers[K]> : never : never

type HandlersFrom<Rpc extends Rpc.Any> = { [Current in Rpc]: Rpc.ToHandlerFn<Current> }

declare function make<Rpcs extends readonly Array<Any>>(...rpcs: Rpcs): RpcGroup<Rpcs[number]>

interface RpcGroup<in out R extends Rpc.Any> extends Pipeable {
  constructor(_: never);
  readonly [TypeId]: typeof TypeId;
  readonly annotations: Context<never>;
  readonly requests: ReadonlyMap<string, R>;
  accessHandler<Tag extends string>(tag: Tag): Effect<(payload: Payload<Extract<R, {
    readonly _tag: Tag;
  }>>, headers: Headers) => ResultFrom<Extract<R, {
    readonly _tag: Tag;
  }>, never>, never, Handler<Tag>>;
  add<Rpcs2 extends readonly Array<Any>>(...rpcs: Rpcs2): RpcGroup<R | Rpcs2[number]>;
  annotate<I, S>(tag: Tag<I, S>, value: S): RpcGroup<R>;
  annotateContext<S>(context: Context<S>): RpcGroup<R>;
  annotateRpcs<I, S>(tag: Tag<I, S>, value: S): RpcGroup<R>;
  annotateRpcsContext<S>(context: Context<S>): RpcGroup<R>;
  merge<Groups extends readonly Array<Any>>(...groups: Groups): RpcGroup<R | Rpcs<Groups[number]>>;
  middleware<M extends TagClassAny>(middleware: M): RpcGroup<AddMiddleware<R, M>>;
  of<Handlers extends HandlersFrom<R>>(handlers: Handlers): Handlers;
  prefix<Prefix extends string>(prefix: Prefix): RpcGroup<Prefixed<R, Prefix>>;
  toHandlersContext<Handlers extends HandlersFrom<R>, EX = never, RX = never>(build: Handlers | Effect<Handlers, EX, RX>): Effect<Context<ToHandler<R>>, EX, RX | HandlersContext<R, Handlers>>;
  toLayer<Handlers extends HandlersFrom<R>, EX = never, RX = never>(build: Handlers | Effect<Handlers, EX, RX>): Layer<ToHandler<R>, EX, Exclude<RX, Scope> | HandlersContext<R, Handlers>>;
  toLayerHandler<Tag extends string, Handler extends never, EX = never, RX = never>(tag: Tag, build: Handler | Effect<Handler, EX, RX>): Layer<Handler<Tag>, EX, Exclude<RX, Scope> | HandlerContext<R, Tag, Handler>>;
}

type Rpcs<Group> = Group extends RpcGroup<infer R> ? string extends R["_tag"] ? never : R : never

declare const TypeId: unique symbol

type TypeId = typeof TypeId