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;