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

export declare const makeSerializable: <Requests extends TaggedRequest.Any, State>() => <
  Req extends Schema.TaggedRequest.Any,
  Fields extends { readonly _tag: Schema.Literal<[Req["_tag"]]> },
  IS,
  R,
  RS
>(
  schema: any,
  handler: Handler<Req, State, Requests, R>
) => SerializableProcedure<Req, State, any>

export 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>

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

export interface BaseContext {
  readonly fork: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<void, never, R>
  readonly forkOne: {
    (id: string): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<void, never, R>
    <A, E, R>(effect: Effect.Effect<A, E, R>, id: string): Effect.Effect<void, never, R>
  }
  readonly forkReplace: {
    (id: string): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<void, never, R>
    <A, E, R>(effect: Effect.Effect<A, E, R>, id: string): Effect.Effect<void, never, R>
  }
  readonly unsafeSend: <Req extends TaggedRequest.Any>(request: Req) => Effect.Effect<void>
  readonly unsafeSendAwait: <Req extends TaggedRequest.Any>(
    request: Req
  ) => Effect.Effect<Request.Success<Req>, Request.Error<Req>>
}

export interface Context<Requests extends TaggedRequest.Any, Request extends TaggedRequest.Any, State>
  extends ContextProto<Requests, State> {
  readonly request: Request
  readonly state: State
  readonly deferred: Deferred.Deferred<Request.Success<Request>, Request.Error<Request>>
}

export interface ContextProto<Requests extends TaggedRequest.Any, State> extends BaseContext {
  readonly send: <Req extends Requests>(request: Req) => Effect.Effect<void>
  readonly sendAwait: <Req extends Requests>(request: Req) => Effect.Effect<Request.Success<Req>, Request.Error<Req>>
  readonly forkWith: {
    (state: State): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<readonly [void, State], never, R>
    <A, E, R>(effect: Effect.Effect<A, E, R>, state: State): Effect.Effect<readonly [void, State], never, R>
  }
  readonly forkOneWith: {
    (
      id: string,
      state: State
    ): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<readonly [void, State], never, R>
    <A, E, R>(effect: Effect.Effect<A, E, R>, id: string, state: State): Effect.Effect<readonly [void, State], never, R>
  }
  readonly forkReplaceWith: {
    (
      id: string,
      state: State
    ): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<readonly [void, State], never, R>
    <A, E, R>(effect: Effect.Effect<A, E, R>, id: string, state: State): Effect.Effect<readonly [void, State], never, R>
  }
}

export type InferContext<P> = P extends Procedure<infer _, infer _, infer R> ? R : never

export type InferRequest<P> = P extends Procedure<infer Req, infer _, infer _> ? Req : never

export interface SerializableProcedure<Request extends Schema.TaggedRequest.Any, State, R>
  extends Procedure<Request, State, R> {
  readonly [SerializableTypeId]: SerializableTypeId
  readonly schema: Schema.Schema<Request, unknown>
}

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

export type Any = TaggedRequest<string, any, any> | TaggedRequest<string, any, never>

export declare const isSerializable: (u: unknown) => u is SerializableProcedure<any, any, any>

export declare const NoReply: typeof NoReply

export type NoReply = typeof NoReply

export declare const SerializableTypeId: typeof SerializableTypeId

export type SerializableTypeId = typeof SerializableTypeId

export declare const TypeId: typeof TypeId

export type TypeId = typeof TypeId