Format of the response entity carrying the client errors.

Convert the ClientErrors type into the endpoints internal client error type

Convert the endpoints internal client error type into the ClientErrors type

Format of the response entity carrying the server error.

Convert the ServerError type into the endpoints internal server error type

Convert the endpoints internal server error type into the ServerError type

A JSON schema for sequences

Bad Request (400) response, with an entity of type ClientErrors.

A JSON schema for type BigDecimal

A JSON schema for type Boolean

Query string parameter containing a Boolean value

A JSON schema for type Byte

Chains the two paths

Alternative between two possible choices of responses.

Server interpreters construct either one or the other response. Client interpreters accept either one or the other response. Documentation interpreters list all the possible responses.

The JSON schema of a coproduct made of the given alternative tagged records

Response used by the endpoints library when decoding a request fails.

The provided implementation forwards to badRequest.

Concatenates two QueryStrings

Default discriminator field name for sum types.

It defaults to "type", but you can override it twofold: - by overriding this field you can change default discriminator name algebra-wide - by using withDiscriminator you can specify discriminator field name for specific sum type

A JSON schema for type String

Helper method to perform DELETE request

A JSON schema for type Double

Codec for query string parameters of type Double

Segment codec for type Double

Implicit conversion to get rid of intellij errors when defining paths. Effectively should not be called.

The JSON schema of a record with no fields

Empty request -- request without a body. Use description of endpoints.algebra.Endpoints#endpoint to document an empty body.

Always succeeds in extracting no information from the headers

An empty response entity

No particular response header. Client interpreters should ignore information carried by response headers.

HTTP endpoint.

Promotes a schema to an enumeration. Decoding fails if the input string does not match the encoded values of any of the possible values. Encoding does never fail, even if the value is not contained in the set of possible values.

The JSON schema of a record with a single field name of type A

A JSON schema for type Float

Helper method to perform GET request

This method is called by endpoints when decoding a request failed.

The provided implementation calls clientErrorsResponse to construct a response containing the errors.

This method can be overridden to customize the error reporting logic.

This method is called by endpoints when an exception is thrown during request processing.

The provided implementation calls serverErrorResponse to construct a response containing the error message.

This method can be overridden to customize the error reporting logic.

A successful HTTP response (status code 200) with an HTML entity

A JSON schema for type Int

Ability to define Int query string parameters

Ability to define Int path segments

Internal Server Error (500) response, with an entity of type ServerError.

Defines a RequestEntity[A] given an implicit JsonRequest[A]

Defines a Response[A] given an implicit JsonResponse[A]

Provides xmap and xmapPartial operations.

Captures a lazy reference to a JSON schema currently being defined:

case class Recursive(next: Option[Recursive])
val recursiveSchema: Record[Recursive] = (
  optField("next")(lazyRecord(recursiveSchema, "Rec"))
).xmap(Recursive)(_.next)

Interpreters should return a JsonSchema value that does not evaluate the given schema unless it is effectively used.

Captures a lazy reference to a JSON schema currently being defined.

Interpreters should return a JsonSchema value that does not evaluate the given schema unless it is effectively used.

A schema for a statically known value.

Encoders always produce the given value, encoded according to tpe. Decoders first try to decode incoming values with the given tpe schema, and then check that it is equal to the given value.

This is useful to model schemas of objects containing extra fields that are absent from their Scala representation. For example, here is a schema for a GeoJSON point:

case class Point(lon: Double, lat: Double)
val pointSchema = (
  field("type")(literal("Point")) zip
  field[(Double, Double)]("coordinates")
).xmap(Point.tupled)(p => (p.lon, p.lat))

A JSON schema for type Long

Query string parameter containing a Long value

Segment containing a Long value

A JSON schema for maps with string keys

Annotates the enum JSON schema with a name

Annotates the record JSON schema with a name

Annotates the tagged JSON schema with a name

OK (200) Response with the given entity

The JSON schema of a record with a single optional field name of type A

Decoder interpreters successfully decode None if the field is absent or if it is present but has the value null. Decoder interpreters fail if the field is present but contains an invalid value. Encoder interpreters can omit the field or emit a field with a null value. Documentation interpreters must mark the field as optional.

An optional request header

Response headers optionally containing a header with the given name. Client interpreters should model the header value as Some[String], or None if the response header is missing. Server interpreters should produce such a response header. Documentation interpreters should document this header.

Make a query string parameter optional:

path / "articles" /? qs[Option[Int]]("page")

Client interpreters must omit optional query string parameters that are empty. Server interpreters must accept incoming requests whose optional query string parameters are missing. Server interpreters must report a failure for incoming requests whose optional query string parameters are present, but malformed.

A schema that can be either schemaA or schemaB.

Documentation interpreter produce a oneOf JSON schema. Encoder interpreters forward to either schemaA or schemaB. Decoder interpreters first try to decode with schemaA, and fallback to schemaB in case of failure.

The difference between this operation and the operation orElse on “tagged” schemas is that this operation does not rely on a discriminator field between the alternative schemas. As a consequence, decoding is slower than with “tagged” schemas and provides less precise error messages.

An empty path.

Useful to begin a path definition:

path / "foo" / segment[Int] /? qs[String]("bar")

Provides xmap and xmapPartial operations.

Helper method to perform POST request

Helper method to perform PUT request

Builds a QueryString with one parameter.

Examples:

qs[Int]("page")            // mandatory `page` parameter
qs[Option[String]]("lang") // optional `lang` parameter
qs[List[Long]]("id")       // repeated `id` parameter

Provides xmap and xmapPartial operations.

Provides xmap and xmapPartial operations.

Provides xmap and xmapPartial operations.

The remaining segments of the path. The String value carried by this Path is still URL-encoded.

Support query string parameters with multiple values:

path / "articles" /? qs[List[Long]]("id")

Server interpreters must accept incoming requests where such parameters are missing (in such a case, its value is an empty collection), and report a failure if at least one value is malformed.

Decodes a request.

Provides the operations xmap and xmapPartial.

A required request header

Provides the operations xmap and xmapPartial.

Provides ++ operation.

Provides the operations xmap and xmapPartial.

Server interpreters construct a response with the given status and entity. Client interpreters accept a response only if it has a corresponding status code.

Response headers containing a header with the given name. Client interpreters should model the header value as String, or fail if the response header is missing. Server interpreters should produce such a response header. Documentation interpreters should document this header.

Example:

val versionedResource: Endpoint[Unit, (SomeResource, String)] =
  endpoint(
    get(path / "versioned-resource"),
    ok(
      jsonResponse[SomeResource],
      headers = responseHeader("ETag")
    )
  )

Provides xmap operation.

Provides ++ operation.

Provides the operation xmap to the type Response

Builds a Play router out of endpoint definitions.

val routes = routesFromEndpoints(
  inc.implementedBy(x => x + 1)
)

A path segment carrying an A information

Provides xmap and xmapPartial operations.

Response used by the endpoints library when the business logic of an endpoint fails.

The provided implementation forwards to internalServerError

A path segment whose value is the given segment

Turns a JsonCodec[A] into a Codec[String, A]

Convenient constructor for enumerations represented by string values.

A JSON schema for type String.

Ability to define String query string parameters

Ability to define String path segments Servers should return an URL-decoded string value, and clients should take an URL-decoded string value.

Provides xmap and xmapPartial operations.

Tags a schema for type A with the given tag name

Request with a String body.

A text entity

A JSON schema for a tuple of 10 elements.

Tuples are represented with JSON arrays, as documented in https://json-schema.org/understanding-json-schema/reference/array.html#tuple-validation.

A JSON schema for a tuple of 11 elements.

Tuples are represented with JSON arrays, as documented in https://json-schema.org/understanding-json-schema/reference/array.html#tuple-validation.

A JSON schema for a tuple of 12 elements.

Tuples are represented with JSON arrays, as documented in https://json-schema.org/understanding-json-schema/reference/array.html#tuple-validation.

A JSON schema for a tuple of 13 elements.

Tuples are represented with JSON arrays, as documented in https://json-schema.org/understanding-json-schema/reference/array.html#tuple-validation.

A JSON schema for a tuple of 14 elements.

Tuples are represented with JSON arrays, as documented in https://json-schema.org/understanding-json-schema/reference/array.html#tuple-validation.

A JSON schema for a tuple of 15 elements.

Tuples are represented with JSON arrays, as documented in https://json-schema.org/understanding-json-schema/reference/array.html#tuple-validation.

A JSON schema for a tuple of 16 elements.

Tuples are represented with JSON arrays, as documented in https://json-schema.org/understanding-json-schema/reference/array.html#tuple-validation.

A JSON schema for a tuple of 17 elements.

Tuples are represented with JSON arrays, as documented in https://json-schema.org/understanding-json-schema/reference/array.html#tuple-validation.

A JSON schema for a tuple of 18 elements.

Tuples are represented with JSON arrays, as documented in https://json-schema.org/understanding-json-schema/reference/array.html#tuple-validation.

A JSON schema for a tuple of 19 elements.

Tuples are represented with JSON arrays, as documented in https://json-schema.org/understanding-json-schema/reference/array.html#tuple-validation.

A JSON schema for a tuple of 20 elements.

Tuples are represented with JSON arrays, as documented in https://json-schema.org/understanding-json-schema/reference/array.html#tuple-validation.

A JSON schema for a tuple of 21 elements.

Tuples are represented with JSON arrays, as documented in https://json-schema.org/understanding-json-schema/reference/array.html#tuple-validation.

A JSON schema for a tuple of 22 elements.

Tuples are represented with JSON arrays, as documented in https://json-schema.org/understanding-json-schema/reference/array.html#tuple-validation.

A JSON schema for a tuple of 2 elements.

Tuples are represented with JSON arrays, as documented in https://json-schema.org/understanding-json-schema/reference/array.html#tuple-validation.

A JSON schema for a tuple of 3 elements.

Tuples are represented with JSON arrays, as documented in https://json-schema.org/understanding-json-schema/reference/array.html#tuple-validation.

A JSON schema for a tuple of 4 elements.

Tuples are represented with JSON arrays, as documented in https://json-schema.org/understanding-json-schema/reference/array.html#tuple-validation.

A JSON schema for a tuple of 5 elements.

Tuples are represented with JSON arrays, as documented in https://json-schema.org/understanding-json-schema/reference/array.html#tuple-validation.

A JSON schema for a tuple of 6 elements.

Tuples are represented with JSON arrays, as documented in https://json-schema.org/understanding-json-schema/reference/array.html#tuple-validation.

A JSON schema for a tuple of 7 elements.

Tuples are represented with JSON arrays, as documented in https://json-schema.org/understanding-json-schema/reference/array.html#tuple-validation.

A JSON schema for a tuple of 8 elements.

Tuples are represented with JSON arrays, as documented in https://json-schema.org/understanding-json-schema/reference/array.html#tuple-validation.

A JSON schema for a tuple of 9 elements.

Tuples are represented with JSON arrays, as documented in https://json-schema.org/understanding-json-schema/reference/array.html#tuple-validation.

Provides xmap and xmapPartial operations

Builds an URL from the given path and query string

A JSON schema for type UUID

Ability to define UUID query string parameters

Ability to define UUID path segments

Turns a Response[A] into a Response[Option[A]].

Interpreters represent None with an empty HTTP response whose status code is 404 (Not Found).

Add a description to the given enum JSON schema

Add a description to the given JSON schema

Add a description to the given record JSON schema

Add a description to the given tagged JSON schema