Expand type parameter names in Endpoint and ServerEndpoint

Author: adamw

core/src/main/scala/sttp/tapir/Endpoint.scala

@@ -28,48 +28,55 @@ import scala.reflect.ClassTag
   *
   * A concise description of an endpoint can be generated using the [[EndpointMetaOps.show]] method.
   *
-  * @tparam A
-  *   Security input parameter types.
-  * @tparam I
-  *   Input parameter types.
-  * @tparam E
-  *   Error output parameter types.
-  * @tparam O
-  *   Output parameter types.
+  * @tparam SECURITY_INPUT
+  *   Security input parameter types, abbreviated as `A`.
+  * @tparam INPUT
+  *   Input parameter types, abbreviated as `I`.
+  * @tparam ERROR_OUTPUT
+  *   Error output parameter types, abbreviated as `E`.
+  * @tparam OUTPUT
+  *   Output parameter types, abbreviated as `O`.
   * @tparam R
   *   The capabilities that are required by this endpoint's inputs/outputs. This might be `Any` (no requirements),
   *   [[sttp.capabilities.Effect]] (the interpreter must support the given effect type), [[sttp.capabilities.Streams]] (the ability to send
   *   and receive streaming bodies) or [[sttp.capabilities.WebSockets]] (the ability to handle websocket requests).
   */
-case class Endpoint[A, I, E, O, -R](
-    securityInput: EndpointInput[A],
-    input: EndpointInput[I],
-    errorOutput: EndpointOutput[E],
-    output: EndpointOutput[O],
+case class Endpoint[SECURITY_INPUT, INPUT, ERROR_OUTPUT, OUTPUT, -R](
+    securityInput: EndpointInput[SECURITY_INPUT],
+    input: EndpointInput[INPUT],
+    errorOutput: EndpointOutput[ERROR_OUTPUT],
+    output: EndpointOutput[OUTPUT],
     info: EndpointInfo
-) extends EndpointSecurityInputsOps[A, I, E, O, R]
-    with EndpointInputsOps[A, I, E, O, R]
-    with EndpointErrorOutputsOps[A, I, E, O, R]
-    with EndpointErrorOutputVariantsOps[A, I, E, O, R]
-    with EndpointOutputsOps[A, I, E, O, R]
+) extends EndpointSecurityInputsOps[SECURITY_INPUT, INPUT, ERROR_OUTPUT, OUTPUT, R]
+    with EndpointInputsOps[SECURITY_INPUT, INPUT, ERROR_OUTPUT, OUTPUT, R]
+    with EndpointErrorOutputsOps[SECURITY_INPUT, INPUT, ERROR_OUTPUT, OUTPUT, R]
+    with EndpointErrorOutputVariantsOps[SECURITY_INPUT, INPUT, ERROR_OUTPUT, OUTPUT, R]
+    with EndpointOutputsOps[SECURITY_INPUT, INPUT, ERROR_OUTPUT, OUTPUT, R]
     with EndpointInfoOps[R]
     with EndpointMetaOps
-    with EndpointServerLogicOps[A, I, E, O, R] { outer =>
+    with EndpointServerLogicOps[SECURITY_INPUT, INPUT, ERROR_OUTPUT, OUTPUT, R] { outer =>
 
   override type EndpointType[_A, _I, _E, _O, -_R] = Endpoint[_A, _I, _E, _O, _R]
-  override type ThisType[-_R] = Endpoint[A, I, E, O, _R]
-  override private[tapir] def withSecurityInput[A2, R2](securityInput: EndpointInput[A2]): Endpoint[A2, I, E, O, R with R2] =
+  override type ThisType[-_R] = Endpoint[SECURITY_INPUT, INPUT, ERROR_OUTPUT, OUTPUT, _R]
+  override private[tapir] def withSecurityInput[A2, R2](
+      securityInput: EndpointInput[A2]
+  ): Endpoint[A2, INPUT, ERROR_OUTPUT, OUTPUT, R with R2] =
     this.copy(securityInput = securityInput)
-  override private[tapir] def withInput[I2, R2](input: EndpointInput[I2]): Endpoint[A, I2, E, O, R with R2] = this.copy(input = input)
-  override private[tapir] def withErrorOutput[E2, R2](errorOutput: EndpointOutput[E2]): Endpoint[A, I, E2, O, R with R2] =
+  override private[tapir] def withInput[I2, R2](input: EndpointInput[I2]): Endpoint[SECURITY_INPUT, I2, ERROR_OUTPUT, OUTPUT, R with R2] =
+    this.copy(input = input)
+  override private[tapir] def withErrorOutput[E2, R2](
+      errorOutput: EndpointOutput[E2]
+  ): Endpoint[SECURITY_INPUT, INPUT, E2, OUTPUT, R with R2] =
     this.copy(errorOutput = errorOutput)
   override private[tapir] def withErrorOutputVariant[E2, R2](
       errorOutput: EndpointOutput[E2],
-      embedE: E => E2
-  ): Endpoint[A, I, E2, O, R with R2] =
+      embedE: ERROR_OUTPUT => E2
+  ): Endpoint[SECURITY_INPUT, INPUT, E2, OUTPUT, R with R2] =
     this.copy(errorOutput = errorOutput)
-  override private[tapir] def withOutput[O2, R2](output: EndpointOutput[O2]): Endpoint[A, I, E, O2, R with R2] = this.copy(output = output)
-  override private[tapir] def withInfo(info: EndpointInfo): Endpoint[A, I, E, O, R] = this.copy(info = info)
+  override private[tapir] def withOutput[O2, R2](output: EndpointOutput[O2]): Endpoint[SECURITY_INPUT, INPUT, ERROR_OUTPUT, O2, R with R2] =
+    this.copy(output = output)
+  override private[tapir] def withInfo(info: EndpointInfo): Endpoint[SECURITY_INPUT, INPUT, ERROR_OUTPUT, OUTPUT, R] =
+    this.copy(info = info)
   override protected def showType: String = "Endpoint"
 }
 
@@ -420,41 +427,41 @@ trait EndpointServerLogicOps[A, I, E, O, -R] { outer: Endpoint[A, I, E, O, R] =>
     * An example use-case is defining an endpoint with fully-defined errors, and with security logic built-in. Such an endpoint can be then
     * extended by multiple other endpoints, by specifying different inputs, outputs and the main logic.
     */
-  def serverSecurityLogic[U, F[_]](f: A => F[Either[E, U]]): PartialServerEndpoint[A, U, I, E, O, R, F] =
+  def serverSecurityLogic[PRINCIPAL, F[_]](f: A => F[Either[E, PRINCIPAL]]): PartialServerEndpoint[A, PRINCIPAL, I, E, O, R, F] =
     PartialServerEndpoint(this, _ => f)
 
   /** Like [[serverSecurityLogic]], but specialised to the case when the result is always a success (`Right`), hence when the logic type can
-    * be simplified to `A => F[U]`.
+    * be simplified to `A => F[PRINCIPAL]`.
     */
-  def serverSecurityLogicSuccess[U, F[_]](
-      f: A => F[U]
-  ): PartialServerEndpoint[A, U, I, E, O, R, F] =
+  def serverSecurityLogicSuccess[PRINCIPAL, F[_]](
+      f: A => F[PRINCIPAL]
+  ): PartialServerEndpoint[A, PRINCIPAL, I, E, O, R, F] =
     PartialServerEndpoint(this, implicit m => a => f(a).map(Right(_)))
 
   /** Like [[serverSecurityLogic]], but specialised to the case when the result is always an error (`Left`), hence when the logic type can
     * be simplified to `A => F[E]`.
     */
-  def serverSecurityLogicError[U, F[_]](
+  def serverSecurityLogicError[PRINCIPAL, F[_]](
       f: A => F[E]
-  ): PartialServerEndpoint[A, U, I, E, O, R, F] =
+  ): PartialServerEndpoint[A, PRINCIPAL, I, E, O, R, F] =
     PartialServerEndpoint(this, implicit m => a => f(a).map(Left(_)))
 
   /** Like [[serverSecurityLogic]], but specialised to the case when the logic function is pure, that is doesn't have any side effects. */
-  def serverSecurityLogicPure[U, F[_]](f: A => Either[E, U]): PartialServerEndpoint[A, U, I, E, O, R, F] =
+  def serverSecurityLogicPure[PRINCIPAL, F[_]](f: A => Either[E, PRINCIPAL]): PartialServerEndpoint[A, PRINCIPAL, I, E, O, R, F] =
     PartialServerEndpoint(this, implicit m => a => f(a).unit)
 
   /** Same as [[serverSecurityLogic]], but requires `E` to be a throwable, and coverts failed effects of type `E` to endpoint errors. */
-  def serverSecurityLogicRecoverErrors[U, F[_]](
-      f: A => F[U]
-  )(implicit eIsThrowable: E <:< Throwable, eClassTag: ClassTag[E]): PartialServerEndpoint[A, U, I, E, O, R, F] =
-    PartialServerEndpoint(this, recoverErrors1[A, E, U, F](f))
+  def serverSecurityLogicRecoverErrors[PRINCIPAL, F[_]](
+      f: A => F[PRINCIPAL]
+  )(implicit eIsThrowable: E <:< Throwable, eClassTag: ClassTag[E]): PartialServerEndpoint[A, PRINCIPAL, I, E, O, R, F] =
+    PartialServerEndpoint(this, recoverErrors1[A, E, PRINCIPAL, F](f))
 
   /** Like [[serverSecurityLogic]], but specialised to the case when the error type is `Unit` (e.g. a fixed status code), and the result of
     * the logic function is an option. A `None` is then treated as an error response.
     */
-  def serverSecurityLogicOption[U, F[_]](
-      f: A => F[Option[U]]
-  )(implicit eIsUnit: E =:= Unit): PartialServerEndpoint[A, U, I, Unit, O, R, F] = {
+  def serverSecurityLogicOption[PRINCIPAL, F[_]](
+      f: A => F[Option[PRINCIPAL]]
+  )(implicit eIsUnit: E =:= Unit): PartialServerEndpoint[A, PRINCIPAL, I, Unit, O, R, F] = {
     import sttp.monad.syntax._
     PartialServerEndpoint(
       this.asInstanceOf[Endpoint[A, I, Unit, O, R]],
@@ -470,43 +477,46 @@ trait EndpointServerLogicOps[A, I, E, O, -R] { outer: Endpoint[A, I, E, O, R] =>
   //
 
   /** Like [[serverSecurityLogic]], but allows the security function to contribute to the overall output of the endpoint. A value for the
-    * complete output `O` defined so far has to be provided. The value `U` will be propagated as an input to the regular logic.
+    * complete output `O` defined so far has to be provided. The value `PRINCIPAL` will be propagated as an input to the regular logic.
     */
-  def serverSecurityLogicWithOutput[U, F[_]](
-      f: A => F[Either[E, (O, U)]]
-  ): PartialServerEndpointWithSecurityOutput[A, U, I, E, O, Unit, R, F] =
+  def serverSecurityLogicWithOutput[PRINCIPAL, F[_]](
+      f: A => F[Either[E, (O, PRINCIPAL)]]
+  ): PartialServerEndpointWithSecurityOutput[A, PRINCIPAL, I, E, O, Unit, R, F] =
     PartialServerEndpointWithSecurityOutput(this.output, this.copy(output = emptyOutput), _ => f)
 
   /** Like [[serverSecurityLogicWithOutput]], but specialised to the case when the result is always a success (`Right`), hence when the
-    * logic type can be simplified to `A => F[(O, U)]`.
+    * logic type can be simplified to `A => F[(O, PRINCIPAL)]`.
     */
-  def serverSecurityLogicSuccessWithOutput[U, F[_]](
-      f: A => F[(O, U)]
-  ): PartialServerEndpointWithSecurityOutput[A, U, I, E, O, Unit, R, F] =
+  def serverSecurityLogicSuccessWithOutput[PRINCIPAL, F[_]](
+      f: A => F[(O, PRINCIPAL)]
+  ): PartialServerEndpointWithSecurityOutput[A, PRINCIPAL, I, E, O, Unit, R, F] =
     PartialServerEndpointWithSecurityOutput(this.output, this.copy(output = emptyOutput), implicit m => a => f(a).map(Right(_)))
 
   /** Like [[serverSecurityLogicWithOutput]], but specialised to the case when the logic function is pure, that is doesn't have any side
     * effects.
     */
-  def serverSecurityLogicPureWithOutput[U, F[_]](
-      f: A => Either[E, (O, U)]
-  ): PartialServerEndpointWithSecurityOutput[A, U, I, E, O, Unit, R, F] =
+  def serverSecurityLogicPureWithOutput[PRINCIPAL, F[_]](
+      f: A => Either[E, (O, PRINCIPAL)]
+  ): PartialServerEndpointWithSecurityOutput[A, PRINCIPAL, I, E, O, Unit, R, F] =
     PartialServerEndpointWithSecurityOutput(this.output, this.copy(output = emptyOutput), implicit m => a => f(a).unit)
 
   /** Same as [[serverSecurityLogicWithOutput]], but requires `E` to be a throwable, and coverts failed effects of type `E` to endpoint
     * errors.
     */
-  def serverSecurityLogicRecoverErrorsWithOutput[U, F[_]](
-      f: A => F[(O, U)]
-  )(implicit eIsThrowable: E <:< Throwable, eClassTag: ClassTag[E]): PartialServerEndpointWithSecurityOutput[A, U, I, E, O, Unit, R, F] =
-    PartialServerEndpointWithSecurityOutput(this.output, this.copy(output = emptyOutput), recoverErrors1[A, E, (O, U), F](f))
+  def serverSecurityLogicRecoverErrorsWithOutput[PRINCIPAL, F[_]](
+      f: A => F[(O, PRINCIPAL)]
+  )(implicit
+      eIsThrowable: E <:< Throwable,
+      eClassTag: ClassTag[E]
+  ): PartialServerEndpointWithSecurityOutput[A, PRINCIPAL, I, E, O, Unit, R, F] =
+    PartialServerEndpointWithSecurityOutput(this.output, this.copy(output = emptyOutput), recoverErrors1[A, E, (O, PRINCIPAL), F](f))
 
   /** Like [[serverSecurityLogicWithOutput]], but specialised to the case when the error type is `Unit` (e.g. a fixed status code), and the
     * result of the logic function is an option. A `None` is then treated as an error response.
     */
-  def serverSecurityLogicOptionWithOutput[U, F[_]](
-      f: A => F[Option[(O, U)]]
-  )(implicit eIsUnit: E =:= Unit): PartialServerEndpointWithSecurityOutput[A, U, I, Unit, O, Unit, R, F] = {
+  def serverSecurityLogicOptionWithOutput[PRINCIPAL, F[_]](
+      f: A => F[Option[(O, PRINCIPAL)]]
+  )(implicit eIsUnit: E =:= Unit): PartialServerEndpointWithSecurityOutput[A, PRINCIPAL, I, Unit, O, Unit, R, F] = {
     import sttp.monad.syntax._
     PartialServerEndpointWithSecurityOutput(
       this.output,

core/src/main/scala/sttp/tapir/package.scala

@@ -10,5 +10,5 @@ package object tapir extends Tapir {
   type AnyListCodec = Codec[_ <: List[_], _, _ <: CodecFormat]
 
   type AnyEndpoint = Endpoint[_, _, _, _, _]
-  type PublicEndpoint[I, E, O, -R] = Endpoint[Unit, I, E, O, R]
+  type PublicEndpoint[INPUT, ERROR_INPUT, OUTPUT, -R] = Endpoint[Unit, INPUT, ERROR_INPUT, OUTPUT, R]
 }

core/src/main/scala/sttp/tapir/server/PartialServerEndpoint.scala

@@ -9,55 +9,58 @@ import scala.reflect.ClassTag
 
 /** An endpoint with the security logic provided, and the main logic yet unspecified. See [[Endpoint.serverSecurityLogic]].
   *
-  * The provided security part of the server logic transforms inputs of type `A`, either to an error of type `E`, or value of type `U`.
+  * The provided security part of the server logic transforms inputs of type `SECURITY_INPUT`, either to an error of type `ERROR_OUTPUT`, or
+  * value of type `PRINCIPAL`.
   *
-  * The part of the server logic which is not provided, will have to transform both `U` and the rest of the input `I` either into an error,
-  * or a value of type `O`.
+  * The part of the server logic which is not provided, will have to transform both `PRINCIPAL` and the rest of the input `INPUT` either
+  * into an error, or a value of type `OUTPUT`.
   *
   * Inputs/outputs can be added to partial endpoints as to regular endpoints. The shape of the error outputs can be adjusted in a limited
   * way, by adding new error output variants, similar as if they were defined using [[Tapir.oneOf]]; the variants and the existing error
   * outputs should usually have a common supertype (other than `Any`). Hence, it's possible to create a base, secured input, and then
   * specialise it with inputs, outputs and logic as needed.
   *
-  * @tparam A
-  *   "Auth": Security input parameter types, which the security logic accepts and returns a `U` or an error `E`.
-  * @tparam U
-  *   "User": The type of the value returned by the security logic.
-  * @tparam I
+  * @tparam SECURITY_INPUT
+  *   Security input parameter types, which the security logic accepts and returns a `PRINCIPAL` or an error `ERROR_OUTPUT`.
+  * @tparam PRINCIPAL
+  *   The type of the value returned by the security logic.
+  * @tparam INPUT
   *   Input parameter types.
-  * @tparam E
+  * @tparam ERROR_OUTPUT
   *   Error output parameter types.
-  * @tparam O
+  * @tparam OUTPUT
   *   Output parameter types.
   * @tparam R
   *   The capabilities that are required by this endpoint's inputs/outputs. `Any`, if no requirements.
   * @tparam F
   *   The effect type used in the provided partial server logic.
   */
-case class PartialServerEndpoint[A, U, I, E, O, -R, F[_]](
-    endpoint: Endpoint[A, I, E, O, R],
-    securityLogic: MonadError[F] => A => F[Either[E, U]]
-) extends EndpointInputsOps[A, I, E, O, R]
-    with EndpointOutputsOps[A, I, E, O, R]
-    with EndpointErrorOutputVariantsOps[A, I, E, O, R]
+case class PartialServerEndpoint[SECURITY_INPUT, PRINCIPAL, INPUT, ERROR_OUTPUT, OUTPUT, -R, F[_]](
+    endpoint: Endpoint[SECURITY_INPUT, INPUT, ERROR_OUTPUT, OUTPUT, R],
+    securityLogic: MonadError[F] => SECURITY_INPUT => F[Either[ERROR_OUTPUT, PRINCIPAL]]
+) extends EndpointInputsOps[SECURITY_INPUT, INPUT, ERROR_OUTPUT, OUTPUT, R]
+    with EndpointOutputsOps[SECURITY_INPUT, INPUT, ERROR_OUTPUT, OUTPUT, R]
+    with EndpointErrorOutputVariantsOps[SECURITY_INPUT, INPUT, ERROR_OUTPUT, OUTPUT, R]
     with EndpointInfoOps[R]
     with EndpointMetaOps { outer =>
-  override type ThisType[-_R] = PartialServerEndpoint[A, U, I, E, O, _R, F]
-  override type EndpointType[_A, _I, _E, _O, -_R] = PartialServerEndpoint[_A, U, _I, _E, _O, _R, F]
+  override type ThisType[-_R] = PartialServerEndpoint[SECURITY_INPUT, PRINCIPAL, INPUT, ERROR_OUTPUT, OUTPUT, _R, F]
+  override type EndpointType[_A, _I, _E, _O, -_R] = PartialServerEndpoint[_A, PRINCIPAL, _I, _E, _O, _R, F]
 
-  override def securityInput: EndpointInput[A] = endpoint.securityInput
-  override def input: EndpointInput[I] = endpoint.input
-  override def errorOutput: EndpointOutput[E] = endpoint.errorOutput
-  override def output: EndpointOutput[O] = endpoint.output
+  override def securityInput: EndpointInput[SECURITY_INPUT] = endpoint.securityInput
+  override def input: EndpointInput[INPUT] = endpoint.input
+  override def errorOutput: EndpointOutput[ERROR_OUTPUT] = endpoint.errorOutput
+  override def output: EndpointOutput[OUTPUT] = endpoint.output
   override def info: EndpointInfo = endpoint.info
 
-  override private[tapir] def withInput[I2, R2](input: EndpointInput[I2]): PartialServerEndpoint[A, U, I2, E, O, R with R2, F] =
+  override private[tapir] def withInput[I2, R2](
+      input: EndpointInput[I2]
+  ): PartialServerEndpoint[SECURITY_INPUT, PRINCIPAL, I2, ERROR_OUTPUT, OUTPUT, R with R2, F] =
     copy(endpoint = endpoint.copy(input = input))
   override private[tapir] def withOutput[O2, R2](output: EndpointOutput[O2]) = copy(endpoint = endpoint.copy(output = output))
   override private[tapir] def withErrorOutputVariant[E2, R2](
       errorOutput: EndpointOutput[E2],
-      embedE: E => E2
-  ): PartialServerEndpoint[A, U, I, E2, O, R with R2, F] =
+      embedE: ERROR_OUTPUT => E2
+  ): PartialServerEndpoint[SECURITY_INPUT, PRINCIPAL, INPUT, E2, OUTPUT, R with R2, F] =
     this.copy(
       endpoint = endpoint.copy(errorOutput = errorOutput),
       securityLogic = implicit m =>
@@ -71,26 +74,39 @@ case class PartialServerEndpoint[A, U, I, E, O, -R, F[_]](
 
   override protected def showType: String = "PartialServerEndpoint"
 
-  def serverLogic(f: U => I => F[Either[E, O]]): ServerEndpoint.Full[A, U, I, E, O, R, F] = ServerEndpoint(endpoint, securityLogic, _ => f)
+  def serverLogic(
+      f: PRINCIPAL => INPUT => F[Either[ERROR_OUTPUT, OUTPUT]]
+  ): ServerEndpoint.Full[SECURITY_INPUT, PRINCIPAL, INPUT, ERROR_OUTPUT, OUTPUT, R, F] = ServerEndpoint(endpoint, securityLogic, _ => f)
 
-  def serverLogicSuccess(f: U => I => F[O]): ServerEndpoint.Full[A, U, I, E, O, R, F] =
+  def serverLogicSuccess(
+      f: PRINCIPAL => INPUT => F[OUTPUT]
+  ): ServerEndpoint.Full[SECURITY_INPUT, PRINCIPAL, INPUT, ERROR_OUTPUT, OUTPUT, R, F] =
     ServerEndpoint(endpoint, securityLogic, implicit m => u => i => f(u)(i).map(Right(_)))
 
-  def serverLogicError(f: U => I => F[E]): ServerEndpoint.Full[A, U, I, E, O, R, F] =
+  def serverLogicError(
+      f: PRINCIPAL => INPUT => F[ERROR_OUTPUT]
+  ): ServerEndpoint.Full[SECURITY_INPUT, PRINCIPAL, INPUT, ERROR_OUTPUT, OUTPUT, R, F] =
     ServerEndpoint(endpoint, securityLogic, implicit m => u => i => f(u)(i).map(Left(_)))
 
-  def serverLogicPure(f: U => I => Either[E, O]): ServerEndpoint.Full[A, U, I, E, O, R, F] =
+  def serverLogicPure(
+      f: PRINCIPAL => INPUT => Either[ERROR_OUTPUT, OUTPUT]
+  ): ServerEndpoint.Full[SECURITY_INPUT, PRINCIPAL, INPUT, ERROR_OUTPUT, OUTPUT, R, F] =
     ServerEndpoint(endpoint, securityLogic, implicit m => u => i => f(u)(i).unit)
 
   def serverLogicRecoverErrors(
-      f: U => I => F[O]
-  )(implicit eIsThrowable: E <:< Throwable, eClassTag: ClassTag[E]): ServerEndpoint.Full[A, U, I, E, O, R, F] =
-    ServerEndpoint(endpoint, securityLogic, recoverErrors2[U, I, E, O, F](f))
+      f: PRINCIPAL => INPUT => F[OUTPUT]
+  )(implicit
+      eIsThrowable: ERROR_OUTPUT <:< Throwable,
+      eClassTag: ClassTag[ERROR_OUTPUT]
+  ): ServerEndpoint.Full[SECURITY_INPUT, PRINCIPAL, INPUT, ERROR_OUTPUT, OUTPUT, R, F] =
+    ServerEndpoint(endpoint, securityLogic, recoverErrors2[PRINCIPAL, INPUT, ERROR_OUTPUT, OUTPUT, F](f))
 
-  def serverLogicOption(f: U => I => F[Option[O]])(implicit eIsUnit: E =:= Unit): ServerEndpoint.Full[A, U, I, Unit, O, R, F] =
+  def serverLogicOption(f: PRINCIPAL => INPUT => F[Option[OUTPUT]])(implicit
+      eIsUnit: ERROR_OUTPUT =:= Unit
+  ): ServerEndpoint.Full[SECURITY_INPUT, PRINCIPAL, INPUT, Unit, OUTPUT, R, F] =
     ServerEndpoint(
-      endpoint.asInstanceOf[Endpoint[A, I, Unit, O, R]],
-      securityLogic.asInstanceOf[MonadError[F] => A => F[Either[Unit, U]]],
+      endpoint.asInstanceOf[Endpoint[SECURITY_INPUT, INPUT, Unit, OUTPUT, R]],
+      securityLogic.asInstanceOf[MonadError[F] => SECURITY_INPUT => F[Either[Unit, PRINCIPAL]]],
       implicit m =>
         u =>
           i =>