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

A request entity carrying chunks of Array[Byte] values

A response entity carrying chunks of Array[Byte] values

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

Override this method to customize the strategy used to encode the JSON schema of coproducts. By default, it uses CoproductEncoding.OneOf.

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.

No particular information. Does not mean that the headers *have to* be empty. Just that, from a server point of view no information will be extracted from them, and from a client point of view no particular headers will be built in the request.

Use description of endpoints.algebra.Endpoints#endpoint to document empty headers.

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

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.

A request entity carrying chunks of JSON values

A response entity carrying chunks of JSON values

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.

Request for given parameters

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

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

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

A request entity carrying chunks of String values

A response entity carrying chunks of String values

Request with a String body.

Text response entity

Convert the internal representation of a JSON schema into the public OpenAPI AST

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.

The JSON codecs used to produce some parts of the documentation.

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