export declare const Tag: <Self>() => <const Id extends string, Rpcs extends Rpc.Any, ER>(
  id: Id,
  options: {
    readonly group: RpcGroup.RpcGroup<Rpcs>
    readonly protocol: Layer.Layer<
      RpcClient.Protocol | Rpc.MiddlewareClient<NoInfer<Rpcs>> | Rpc.Context<NoInfer<Rpcs>>,
      ER
    >
    readonly spanPrefix?: string | undefined
    readonly spanAttributes?: Record<string, unknown> | undefined
    readonly generateRequestId?: (() => RequestId) | undefined
    readonly disableTracing?: boolean | undefined
  }
) => AtomRpcClient<Self, Id, Rpcs, ER>

export interface AtomRpcClient<Self, Id extends string, Rpcs extends Rpc.Any, E>
  extends Context.Tag<Self, RpcClient.RpcClient.Flat<Rpcs, RpcClientError>> {
  new (_: never): Context.TagClassShape<Id, RpcClient.RpcClient.Flat<Rpcs, RpcClientError>>

  readonly layer: Layer.Layer<Self, E>
  readonly runtime: Atom.AtomRuntime<Self, E>

  readonly mutation: <Tag extends Rpc.Tag<Rpcs>>(
    arg: Tag
  ) => Rpc.ExtractTag<Rpcs, Tag> extends Rpc.Rpc<
    infer _Tag,
    infer _Payload,
    infer _Success,
    infer _Error,
    infer _Middleware
  >
    ? [_Success] extends [RpcSchema.Stream<infer _A, infer _E>]
      ? never
      : Atom.AtomResultFn<
          {
            readonly payload: Rpc.PayloadConstructor<Rpc.ExtractTag<Rpcs, Tag>>
            readonly reactivityKeys?:
              | ReadonlyArray<unknown>
              | ReadonlyRecord<string, ReadonlyArray<unknown>>
              | undefined
            readonly headers?: Headers.Input | undefined
          },
          _Success["Type"],
          _Error["Type"] | E | _Middleware["failure"]["Type"]
        >
    : never

  readonly query: <Tag extends Rpc.Tag<Rpcs>>(
    tag: Tag,
    payload: Rpc.PayloadConstructor<Rpc.ExtractTag<Rpcs, Tag>>,
    options?: {
      readonly headers?: Headers.Input | undefined
      readonly reactivityKeys?: ReadonlyArray<unknown> | undefined
      readonly timeToLive?: Duration.DurationInput | undefined
    }
  ) => Rpc.ExtractTag<Rpcs, Tag> extends Rpc.Rpc<
    infer _Tag,
    infer _Payload,
    infer _Success,
    infer _Error,
    infer _Middleware
  >
    ? [_Success] extends [RpcSchema.Stream<infer _A, infer _E>]
      ? Atom.Writable<
          Atom.PullResult<_A["Type"], _E["Type"] | _Error["Type"] | E | _Middleware["failure"]["Type"]>,
          void
        >
      : Atom.Atom<Result.Result<_Success["Type"], _Error["Type"] | E | _Middleware["failure"]["Type"]>>
    : never
}