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>;
}