type FromGroup<Group> = RpcClient<RpcGroup.Rpcs<Group>>

type RpcClient<Rpcs, E> = {
  readonly [Current in Rpcs as Current["_tag"]]: <const AsMailbox extends boolean = false, const Discard = false>(
    input: Rpc.PayloadConstructor<Current>,
    options?: Rpc.Success<Current> extends Stream.Stream<infer _A, infer _E, infer _R>
      ? {
          readonly asMailbox?: AsMailbox | undefined
          readonly streamBufferSize?: number | undefined
          readonly headers?: Headers.Input | undefined
          readonly context?: Context.Context<never> | undefined
        }
      : {
          readonly headers?: Headers.Input | undefined
          readonly context?: Context.Context<never> | undefined
          readonly discard?: Discard | undefined
        }
  ) => Current extends Rpc.Rpc<infer _Tag, infer _Payload, infer _Success, infer _Error, infer _Middleware>
    ? [_Success] extends [RpcSchema.Stream<infer _A, infer _E>]
      ? AsMailbox extends true
        ? Effect.Effect<
            Mailbox.ReadonlyMailbox<_A["Type"], _E["Type"] | _Error["Type"] | E>,
            never,
            Scope.Scope | _Payload["Context"] | _Success["Context"] | _Error["Context"]
          >
        : Stream.Stream<
            _A["Type"],
            _E["Type"] | _Error["Type"] | E,
            _Payload["Context"] | _Success["Context"] | _Error["Context"]
          >
      : Effect.Effect<
          Discard extends true ? void : _Success["Type"],
          Discard extends true ? never : _Error["Type"] | E,
          _Payload["Context"] | _Success["Context"] | _Error["Context"]
        >
    : never
}

declare const make: <Rpcs extends Rpc.Any>(
  group: RpcGroup.RpcGroup<Rpcs>,
  options?:
    | {
        readonly spanPrefix?: string | undefined
        readonly generateRequestId?: (() => RequestId) | undefined
        readonly disableTracing?: boolean | undefined
      }
    | undefined
) => Effect.Effect<RpcClient<Rpcs>, never, Protocol | Rpc.MiddlewareClient<Rpcs> | Scope.Scope>

declare const makeNoSerialization: <Rpcs extends Rpc.Any, E>(
  group: RpcGroup.RpcGroup<Rpcs>,
  options: {
    readonly onFromClient: (options: {
      readonly message: FromClient<Rpcs>
      readonly context: Context.Context<never>
      readonly discard: boolean
    }) => Effect.Effect<void, E>
    readonly supportsAck?: boolean | undefined
    readonly spanPrefix?: string | undefined
    readonly generateRequestId?: (() => RequestId) | undefined
    readonly disableTracing?: boolean | undefined
  }
) => Effect.Effect<
  { readonly client: RpcClient<Rpcs, E>; readonly write: (message: FromServer<Rpcs>) => Effect.Effect<void> },
  never,
  Scope.Scope | Rpc.MiddlewareClient<Rpcs>
>

declare const currentHeaders: FiberRef.FiberRef<Headers.Headers>

declare const withHeaders: {
  (headers: Headers.Input): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
  <A, E, R>(effect: Effect.Effect<A, E, R>, headers: Headers.Input): Effect.Effect<A, E, R>
}

declare const withHeadersEffect: {
  <E2, R2>(
    headers: Effect.Effect<Headers.Input, E2, R2>
  ): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E | E2, R | R2>
  <A, E, R, E2, R2>(
    effect: Effect.Effect<A, E, R>,
    headers: Effect.Effect<Headers.Input, E2, R2>
  ): Effect.Effect<A, E | E2, R | R2>
}

declare class Protocol

declare const layerProtocolHttp: (options: {
  readonly url: string
  readonly transformClient?: <E, R>(client: HttpClient.HttpClient.With<E, R>) => HttpClient.HttpClient.With<E, R>
}) => Layer.Layer<Protocol, never, RpcSerialization.RpcSerialization | HttpClient.HttpClient>

declare const layerProtocolSocket: Layer.Layer<Protocol, never, any>

declare const layerProtocolWorker: (
  options:
    | {
        readonly size: number
        readonly concurrency?: number | undefined
        readonly targetUtilization?: number | undefined
      }
    | {
        readonly minSize: number
        readonly maxSize: number
        readonly concurrency?: number | undefined
        readonly targetUtilization?: number | undefined
        readonly timeToLive: Duration.DurationInput
      }
) => Layer.Layer<Protocol, WorkerError, Worker.PlatformWorker | Worker.Spawner>

declare const makeProtocolHttp: (
  client: HttpClient.HttpClient
) => Effect.Effect<Protocol["Type"], never, RpcSerialization.RpcSerialization>

declare const makeProtocolSocket: Effect.Effect<any, never, any>

declare const makeProtocolWorker: (
  options:
    | {
        readonly size: number
        readonly concurrency?: number | undefined
        readonly targetUtilization?: number | undefined
      }
    | {
        readonly minSize: number
        readonly maxSize: number
        readonly concurrency?: number | undefined
        readonly targetUtilization?: number | undefined
        readonly timeToLive: Duration.DurationInput
      }
) => Effect.Effect<Protocol["Type"], WorkerError, Scope.Scope | Worker.PlatformWorker | Worker.Spawner>