Adds a new error variant, where the current error output is represented as a Left, and the given one as a Right.

Replaces the current error output with a Tapir.oneOf output, where:

• the first output variant is the current output: oneOfVariant(errorOutput)
• the second output variant is the given o

The variant for the current endpoint output will be created using Tapir.oneOfVariant. Hence, the current output will be used if the run-time class of the output matches E. If the erasure of the E type is different from E, there will be a compile-time failure, as no such run-time check is possible. In this case, use errorOutVariantsFromCurrent and create a variant using one of the other variant factory methods (e.g. Tapir.oneOfVariantValueMatcher).

During encoding/decoding, the new o variant will be considered after the current variant.

Usage example:

sealed trait Parent
case class Child1(v: String) extends Parent
case class Child2(v: String) extends Parent

val e: PublicEndpoint[Unit, Parent, Unit, Any] = endpoint
  .errorOut(stringBody.mapTo[Child1])
  .errorOutVariant[Parent](oneOfVariant(stringBody.mapTo[Child2]))

Adding error output variants is useful when extending the error outputs in a PartialServerEndpoint, created using EndpointServerLogicOps.serverSecurityLogic.

Replaces the current error output with a Tapir.oneOf output, where:

• the first output variant is the given o
• the second, default output variant is the current output: oneOfDefaultVariant(errorOutput)

Useful for adding specific error variants, while the more general ones are already covered by the existing error output.

During encoding/decoding, the new o variant will be considered before the current variant.

Adding error output variants is useful when extending the error outputs in a PartialServerEndpoint, created using EndpointServerLogicOps.serverSecurityLogic.

Same as errorOutVariant, but allows appending multiple variants in one go.

Replace the error output with a Tapir.oneOf output, using the variants returned by variants. The current output should be included in one of the returned variants.

Allows creating the variant list in a custom order, placing the current variant in an arbitrary position, and using default variants if necessary.

Adding error output variants is useful when extending the error outputs in a PartialServerEndpoint, created using EndpointServerLogicOps.serverSecurityLogic.

The method defined in a fixed method input in this endpoint, if any (using e.g. EndpointInputsOps.get or EndpointInputsOps.post).

Combine this public endpoint description with a function, which implements the server-side logic. The logic returns a result, which is either an error or a successful output, wrapped in an effect type F. For secure endpoints, use serverSecurityLogic.

A server endpoint can be passed to a server interpreter. Each server interpreter supports effects of a specific type(s).

Both the endpoint and logic function are considered complete, and cannot be later extended through the returned ServerEndpoint value (except for endpoint meta-data). Secure endpoints allow providing the security logic before all the inputs and outputs are specified.

Like serverLogic, but specialised to the case when the result is always an error (Left), hence when the logic type can be simplified to I => F[E].

Like serverLogic, 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.

Like serverLogic, but specialised to the case when the logic function is pure, that is doesn't have any side effects.

Same as serverLogic, but requires E to be a throwable, and converts failed effects of type E to endpoint errors.

Like serverLogic, but specialised to the case when the result is always a success (Right), hence when the logic type can be simplified to I => F[O].

Combine this endpoint description with a function, which implements the security logic of the endpoint.

Subsequently, the endpoint inputs and outputs can be extended (for error outputs, new variants can be added, but they cannot be arbitrarily extended). Then the main server logic can be provided, given a function which accepts as arguments the result of the security logic and the remaining input. The final result is then a ServerEndpoint.

A complete server endpoint can be passed to a server interpreter. Each server interpreter supports effects of a specific type(s).

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.

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].

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.

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.

Like serverSecurityLogic, but specialised to the case when the logic function is pure, that is doesn't have any side effects.

Like serverSecurityLogicWithOutput, but specialised to the case when the logic function is pure, that is doesn't have any side effects.

Same as serverSecurityLogic, but requires E to be a throwable, and converts failed effects of type E to endpoint errors.

Same as serverSecurityLogicWithOutput, but requires E to be a throwable, and converts failed effects of type E to endpoint errors.

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[PRINCIPAL].

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, PRINCIPAL)].

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 PRINCIPAL will be propagated as an input to the regular logic.

Basic information about the endpoint, excluding mapping information, with inputs sorted (first the method, then path, etc.). E.g.: POST /books /add {header Authorization} {body as application/json (UTF-8)} -> {body as text/plain (UTF-8)}/-

Detailed description of the endpoint, with inputs/outputs represented in the same order as originally defined, including mapping information. E.g.:

Endpoint(securityin: -, in: /books POST /add {body as application/json (UTF-8)} {header Authorization}, errout: {body as text/plain (UTF-8)}, out: -)

Shows endpoint path, by default all parametrised path and query components are replaced by {param_name} or {paramN}, e.g. for

endpoint.in("p1" / path[String] / query[String]("par2"))

returns /p1/{param1}?par2={par2}

Equivalent to .toString, shows the whole case class structure.

Shortened information about the endpoint. If the endpoint is named, returns the name, e.g. [my endpoint]. Otherwise, returns the string representation of the method (if any) and path, e.g. POST /books/add

Append t to the existing tags.

Append ts to the existing tags.

Overwrite the existing tags with a single tag t.

Overwrite the existing tags with ts.

Remove all tags from this endpoint.