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