Procedure

declare function make<Requests extends Any, State>(): <Req extends Any>() => <R>(tag: Req["_tag"], handler: Handler<Req, State, Requests, R>) => Procedure<Req, State, R>

declare function makeSerializable<Requests extends Any, State>(): <Req extends All, IS, R, RS>(schema: any, handler: Handler<Req, State, Requests, R>) => SerializableProcedure<Req, State, any>

type Handler<Request extends TaggedRequest.Any, State, Requests extends TaggedRequest.Any, R> = (context: Procedure.Context<Requests | Request, Request, State>) => Effect.Effect<readonly [response: Request.Success<Request> | NoReply, state: State], Request.Error<Request>, R>

interface Procedure<Request extends TaggedRequest.Any, State, R> extends Pipeable {
  readonly [TypeId]: typeof TypeId;
  readonly handler: Handler<Request, State, any, R>;
  readonly tag: Request["_tag"];
}

interface SerializableProcedure<Request extends Schema.TaggedRequest.All, State, R> extends Procedure<Request, State, R> {
  readonly [SerializableTypeId]: typeof SerializableTypeId;
  readonly schema: any;
}

interface TaggedRequest<Tag extends string, A, E> extends Request<A, E> {
  readonly _tag: Tag;
}

declare function isSerializable(u: unknown): u is SerializableProcedure<any, any, any>

declare const NoReply: typeof NoReply

type NoReply = typeof NoReply

declare const SerializableTypeId: unique symbol

type SerializableTypeId = typeof SerializableTypeId

declare const TypeId: unique symbol

type TypeId = typeof TypeId