RpcServer

declare function toWebHandler<Rpcs extends Any, LE>(group: RpcGroup<Rpcs>, options: {
  readonly disableFatalDefects?: boolean;
  readonly disableTracing?: boolean;
  readonly layer: Layer<any, LE>;
  readonly memoMap?: MemoMap;
  readonly middleware?: (httpApp: Default) => Default<never, DefaultServices>;
  readonly spanAttributes?: Record<string, unknown>;
  readonly spanPrefix?: string;
}): {
  readonly dispose: () => Promise<void>;
  readonly handler: (request: Request, context?: Context<never>) => Promise<Response>;
}

declare const toHttpApp: <Rpcs extends Rpc.Any>(group: RpcGroup.RpcGroup<Rpcs>, options?: {
  readonly disableFatalDefects?: boolean;
  readonly disableTracing?: boolean;
  readonly spanAttributes?: Record<string, unknown>;
  readonly spanPrefix?: string;
}) => Effect.Effect<HttpApp.Default<never, Scope.Scope>, never, Scope.Scope | RpcSerialization.RpcSerialization | Rpc.ToHandler<Rpcs> | Rpc.Context<Rpcs> | Rpc.Middleware<Rpcs>>

declare const toHttpAppWebsocket: <Rpcs extends Rpc.Any>(group: RpcGroup.RpcGroup<Rpcs>, options?: {
  readonly disableFatalDefects?: boolean;
  readonly disableTracing?: boolean;
  readonly spanAttributes?: Record<string, unknown>;
  readonly spanPrefix?: string;
}) => Effect.Effect<HttpApp.Default<never, Scope.Scope>, never, Scope.Scope | RpcSerialization.RpcSerialization | Rpc.ToHandler<Rpcs> | Rpc.Context<Rpcs> | Rpc.Middleware<Rpcs>>

declare const fiberIdClientInterrupt: Runtime

declare const fiberIdTransientInterrupt: Runtime

declare function layerHttpRouter<Rpcs extends Any>(options: {
  readonly concurrency?: number | "unbounded";
  readonly disableFatalDefects?: boolean;
  readonly disableTracing?: boolean;
  readonly group: RpcGroup<Rpcs>;
  readonly path: PathInput;
  readonly protocol?: "http" | "websocket";
  readonly spanAttributes?: Record<string, unknown>;
  readonly spanPrefix?: string;
}): Layer<never, never, any>

declare function layerProtocolHttp<I = Default>(options: {
  readonly path: PathInput;
  readonly routerTag?: any;
}): Layer<Protocol, never, RpcSerialization>

declare function layerProtocolHttpRouter(options: {
  readonly path: PathInput;
}): Layer<Protocol, never, any>

declare const layerProtocolSocketServer: Layer.Layer<Protocol, never, RpcSerialization.RpcSerialization | SocketServer.SocketServer>

declare function layerProtocolStdio<EIn, EOut, RIn, ROut>(options: {
  readonly stdin: Stream<Uint8Array<ArrayBufferLike>, EIn, RIn>;
  readonly stdout: Sink<void, string | Uint8Array<ArrayBufferLike>, unknown, EOut, ROut>;
}): Layer<Protocol, never, RpcSerialization | RIn | ROut>

declare function layerProtocolWebsocket<I = Default>(options: {
  readonly path: PathInput;
  readonly routerTag?: any;
}): Layer<Protocol, never, RpcSerialization>

declare function layerProtocolWebsocketRouter(options: {
  readonly path: PathInput;
}): Layer<Protocol, never, any>

declare const layerProtocolWorkerRunner: Layer.Layer<Protocol, WorkerError, WorkerRunner.PlatformRunner>

declare const makeProtocolHttp: <I = Default>(...args: [options: {
  readonly path: PathInput;
  readonly routerTag?: any;
}]) => Effect<any, unknown, unknown>

declare const makeProtocolHttpRouter: (...args: [options: {
  readonly path: PathInput;
}]) => Effect<any, unknown, unknown>

declare const makeProtocolSocketServer: Effect<any, unknown, unknown>

declare const makeProtocolStdio: <EIn, EOut, RIn, ROut>(...args: [options: {
  readonly stdin: Stream<Uint8Array<ArrayBufferLike>, EIn, RIn>;
  readonly stdout: Sink<void, string | Uint8Array<ArrayBufferLike>, unknown, EOut, ROut>;
}]) => Effect<any, unknown, unknown>

declare const makeProtocolWebsocket: <I = HttpRouter.Default>(options: {
  readonly path: HttpRouter.PathInput;
  readonly routerTag?: Context.Tag<I, HttpRouter.HttpRouter.Service<any, any>>;
}) => Effect.Effect<Protocol["Type"], never, RpcSerialization.RpcSerialization | I>

declare const makeProtocolWebsocketRouter: (options: {
  readonly path: HttpRouter.PathInput;
}) => Effect.Effect<Protocol["Type"], never, RpcSerialization.RpcSerialization | HttpLayerRouter.HttpRouter>

declare const makeProtocolWithHttpApp: Effect.Effect<{
  readonly httpApp: HttpApp.Default<never, Scope.Scope>;
  readonly protocol: Protocol["Type"];
}, never, RpcSerialization.RpcSerialization>

declare const makeProtocolWithHttpAppWebsocket: Effect.Effect<{
  readonly httpApp: HttpApp.Default<never, Scope.Scope>;
  readonly protocol: Protocol["Type"];
}, never, RpcSerialization.RpcSerialization>

declare const makeProtocolWorkerRunner: Effect.Effect<Protocol["Type"], WorkerError, WorkerRunner.PlatformRunner | Scope.Scope>

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

declare function layer<Rpcs extends Any>(group: RpcGroup<Rpcs>, options?: {
  readonly concurrency?: number | "unbounded";
  readonly disableFatalDefects?: boolean;
  readonly disableTracing?: boolean;
  readonly spanAttributes?: Record<string, unknown>;
  readonly spanPrefix?: string;
}): Layer<never, never, Protocol | ToHandler<Rpcs> | Context<Rpcs> | Middleware<Rpcs>>

declare const make: <Rpcs extends Rpc.Any>(group: RpcGroup.RpcGroup<Rpcs>, options?: {
  readonly concurrency?: number | "unbounded";
  readonly disableFatalDefects?: boolean;
  readonly disableTracing?: boolean;
  readonly spanAttributes?: Record<string, unknown>;
  readonly spanPrefix?: string;
}) => Effect.Effect<never, never, Protocol | Rpc.ToHandler<Rpcs> | Rpc.Middleware<Rpcs> | Rpc.Context<Rpcs>>

declare const makeNoSerialization: <Rpcs extends Rpc.Any>(group: RpcGroup.RpcGroup<Rpcs>, options: {
  readonly concurrency?: number | "unbounded";
  readonly disableClientAcks?: boolean;
  readonly disableFatalDefects?: boolean;
  readonly disableSpanPropagation?: boolean;
  readonly disableTracing?: boolean;
  readonly onFromServer: (response: FromServer<Rpcs>) => Effect.Effect<void>;
  readonly spanAttributes?: Record<string, unknown>;
  readonly spanPrefix?: string;
}) => Effect.Effect<RpcServer<Rpcs>, never, Rpc.ToHandler<Rpcs> | Rpc.Middleware<Rpcs> | Scope.Scope>

interface RpcServer<A extends Rpc.Any> {
  readonly disconnect: (clientId: number) => Effect<void>;
  readonly write: (clientId: number, message: FromClient<A>) => Effect<void>;
}