RpcClient

type FromGroup<Group, E = never> = RpcClient<RpcGroup.Rpcs<Group>, E>

declare const make: <Rpcs extends Rpc.Any, Flatten extends boolean = false>(group: RpcGroup.RpcGroup<Rpcs>, options?: {
  readonly disableTracing?: boolean;
  readonly flatten?: Flatten;
  readonly generateRequestId?: () => RequestId;
  readonly spanAttributes?: Record<string, unknown>;
  readonly spanPrefix?: string;
}) => Effect.Effect<Flatten extends true ? RpcClient.Flat<Rpcs, RpcClientError> : RpcClient<Rpcs, RpcClientError>, never, Protocol | Rpc.MiddlewareClient<Rpcs> | Scope.Scope>

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

type RpcClient<Rpcs extends Rpc.Any, E = never> = Schema.Simplify<RpcClient.From<RpcClient.NonPrefixed<Rpcs>, E, ""> & { [CurrentPrefix in RpcClient.Prefixes<Rpcs>]: RpcClient.From<RpcClient.Prefixed<Rpcs, CurrentPrefix>, E, CurrentPrefix> }>

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

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

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

declare function layerProtocolHttp(options: {
  readonly transformClient?: <E, R>(client: With<E, R>) => With<E, R>;
  readonly url: string;
}): Layer<Protocol, never, any>

declare function layerProtocolSocket(options?: {
  readonly retrySchedule?: Schedule<any, SocketError, never, never>;
  readonly retryTransientErrors?: boolean;
}): Layer<Protocol, never, any>

declare function layerProtocolWorker(options: {
  readonly concurrency?: number;
  readonly size: number;
  readonly targetUtilization?: number;
} | {
  readonly concurrency?: number;
  readonly maxSize: number;
  readonly minSize: number;
  readonly targetUtilization?: number;
  readonly timeToLive: DurationInput;
}): Layer<Protocol, WorkerError, any>

declare function makeProtocolHttp(client: HttpClient): Effect<any, never, RpcSerialization>

declare function makeProtocolSocket(options?: {
  readonly retrySchedule?: Schedule<any, SocketError, never, never>;
  readonly retryTransientErrors?: boolean;
}): Effect<any, never, any>

declare function makeProtocolWorker(options: {
  readonly concurrency?: number;
  readonly size: number;
  readonly targetUtilization?: number;
} | {
  readonly concurrency?: number;
  readonly maxSize: number;
  readonly minSize: number;
  readonly targetUtilization?: number;
  readonly timeToLive: DurationInput;
}): Effect<any, WorkerError, any>

declare class Protocol extends any {
  constructor();
  static make: <EX, RX>(f: (write: any) => Effect<Omit<any, "run">, EX, RX>) => Effect<any, EX, RX>;
}