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;