com.holonplatform.reactor.http

## Interface ReactiveRestClient.ReactiveInvocation

- All Superinterfaces:
    com.holonplatform.http.rest.RestClientOperations.InvocationOperations<reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<InputStream>,reactor.core.publisher.Flux<?>,reactor.core.publisher.Mono<URI>>
  All Known Subinterfaces:
    ReactiveRestClient.ReactiveRequestDefinition
  All Known Implementing Classes:
    DefaultReactiveRequestDefinition
  Enclosing interface:
    ReactiveRestClient

      public static interface ReactiveRestClient.ReactiveInvocation
      extends com.holonplatform.http.rest.RestClientOperations.InvocationOperations<reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<InputStream>,reactor.core.publisher.Flux<?>,reactor.core.publisher.Mono<URI>>

  Invocation operations

- - ### Method Summary

    All Methods Instance Methods Abstract Methods Default Methods
    Modifier and Type | Method and Description
    --- | ---
    `default reactor.core.publisher.Mono<ReactiveResponseEntity<Void>>` | `delete()` Invoke the request using `DELETE` method and asynchronously receive a response back.
    `default <T> reactor.core.publisher.Mono<ReactiveResponseEntity<T>>` | `delete(Class<T> responseType)` Invoke the request asynchronously using the `DELETE` method and receive a response back.
    `default <T> reactor.core.publisher.Mono<ReactiveResponseEntity<T>>` | `delete(com.holonplatform.http.rest.ResponseType<T> responseType)` Invoke the request using `DELETE` method and asynchronously receive a response back.
    `default <T> reactor.core.publisher.Mono<T>` | `deleteForEntity(Class<T> responseType)` Invoke the request using `DELETE` method and asynchronously receive the response entity payload back.
    `default <T> reactor.core.publisher.Mono<T>` | `deleteForEntity(com.holonplatform.http.rest.ResponseType<T> responseType)` Invoke the request using `DELETE` method and asynchronously receive the response entity payload of given generic type back.
    `default reactor.core.publisher.Mono<Void>` | `deleteOrFail()` Invoke the request asynchronously using the `DELETE` method.
    `default <T> reactor.core.publisher.Mono<ReactiveResponseEntity<T>>` | `get(Class<T> responseType)` Invoke the request using `GET` method and asynchronously receive a response back.
    `default <T> reactor.core.publisher.Mono<ReactiveResponseEntity<T>>` | `get(com.holonplatform.http.rest.ResponseType<T> responseType)` Invoke the request using `GET` method and asynchronously receive a response back.
    `default <T> reactor.core.publisher.Flux<T>` | `getAsList(Class<T> responseType)` Convenience method to invoke the request using `GET` method and asynchronously receive a response entity payload of `List` type back.
    `default <T> reactor.core.publisher.Mono<T>` | `getForEntity(Class<T> responseType)` Invoke the request using `GET` method and asynchronously receive the response entity payload back.
    `default <T> reactor.core.publisher.Mono<T>` | `getForEntity(com.holonplatform.http.rest.ResponseType<T> responseType)` Invoke the request using `GET` method and asynchronously receive the response entity payload of given generic type back.
    `default reactor.core.publisher.Mono<InputStream>` | `getForStream()` Invoke the request using `GET` method and asynchronously receive the response entity `InputStream` back.
    `default reactor.core.publisher.Mono<ReactiveResponseEntity<Void>>` | `head()` Invoke the request using `HEAD` method and asynchronously receive a response back.
    `<T,R> reactor.core.publisher.Mono<ReactiveResponseEntity<T>>` | `invoke(com.holonplatform.http.HttpMethod method, com.holonplatform.http.rest.RequestEntity<R> requestEntity, com.holonplatform.http.rest.ResponseType<T> responseType)` Invoke the request and asynchronously receive a response back.
    `<T,R> reactor.core.publisher.Mono<T>` | `invokeForEntity(com.holonplatform.http.HttpMethod method, com.holonplatform.http.rest.RequestEntity<R> requestEntity, com.holonplatform.http.rest.ResponseType<T> responseType)` Invoke the request and asynchronously receive back the response content entity.
    `<T,R> reactor.core.publisher.Flux<T>` | `invokeForFlux(com.holonplatform.http.HttpMethod method, com.holonplatform.http.rest.RequestEntity<R> requestEntity, Class<T> responseElementType)` Invoke the request and asynchronously receive back the response as a `Flux` of response entity elements.
    `<R> reactor.core.publisher.Mono<InputStream>` | `invokeForStream(com.holonplatform.http.HttpMethod method, com.holonplatform.http.rest.RequestEntity<R> requestEntity)` Invoke the request and asynchronously receive back the response as a raw `InputStream`.
    `<T,R> reactor.core.publisher.Mono<ReactiveResponseEntity<T>>` | `invokeForSuccess(com.holonplatform.http.HttpMethod method, com.holonplatform.http.rest.RequestEntity<R> requestEntity, com.holonplatform.http.rest.ResponseType<T> responseType)` Invoke the request and asynchronously receive a response back only if the response has a success (`2xx`) status code.
    `default reactor.core.publisher.Mono<ReactiveResponseEntity<Void>>` | `options()` Invoke the request using `OPTIONS` method and asynchronously receive a response back.
    `default <T> reactor.core.publisher.Mono<ReactiveResponseEntity<T>>` | `options(Class<T> responseType)` Invoke the request using `OPTIONS` method and asynchronously receive a response back.
    `default <T> reactor.core.publisher.Mono<ReactiveResponseEntity<T>>` | `options(com.holonplatform.http.rest.ResponseType<T> responseType)` Invoke the request using `OPTIONS` method and asynchronously receive a response back.
    `default <T> reactor.core.publisher.Mono<T>` | `optionsForEntity(Class<T> responseType)` Invoke the request using `OPTIONS` method and asynchronously receive the response entity payload back.
    `default <T> reactor.core.publisher.Mono<T>` | `optionsForEntity(com.holonplatform.http.rest.ResponseType<T> responseType)` Invoke the request using `OPTIONS` method and asynchronously receive the response entity payload of given generic type back.
    `default reactor.core.publisher.Mono<ReactiveResponseEntity<Void>>` | `patch(com.holonplatform.http.rest.RequestEntity<?> entity)` Invoke the request using `PATCH` method with given `entity` request payload and asynchronously receive a response back.
    `default <T> reactor.core.publisher.Mono<ReactiveResponseEntity<T>>` | `patch(com.holonplatform.http.rest.RequestEntity<?> entity, Class<T> responseType)` Invoke the request using `PATCH` method with given `entity` request payload and asynchronously receive a response back.
    `default <T> reactor.core.publisher.Mono<ReactiveResponseEntity<T>>` | `patch(com.holonplatform.http.rest.RequestEntity<?> entity, com.holonplatform.http.rest.ResponseType<T> responseType)` Invoke the request using `PATCH` method with given `entity` request payload and asynchronously receive a response back.
    `default <T> reactor.core.publisher.Mono<T>` | `patchForEntity(com.holonplatform.http.rest.RequestEntity<?> entity, Class<T> responseType)` Invoke the request using `PATCH` method with given `entity` request payload and asynchronously receive the response entity payload back.
    `default <T> reactor.core.publisher.Mono<T>` | `patchForEntity(com.holonplatform.http.rest.RequestEntity<?> entity, com.holonplatform.http.rest.ResponseType<T> responseType)` Invoke the request using `PATCH` method with given `entity` request payload and asynchronously receive the response entity payload back.
    `default reactor.core.publisher.Mono<ReactiveResponseEntity<Void>>` | `post(com.holonplatform.http.rest.RequestEntity<?> entity)` Invoke the request using `POST` method with given `entity` request payload and asynchronously receive a response back.
    `default <T> reactor.core.publisher.Mono<ReactiveResponseEntity<T>>` | `post(com.holonplatform.http.rest.RequestEntity<?> entity, Class<T> responseType)` Invoke the request using `POST` method with given `entity` request payload and asynchronously receive a response back.
    `default <T> reactor.core.publisher.Mono<ReactiveResponseEntity<T>>` | `post(com.holonplatform.http.rest.RequestEntity<?> entity, com.holonplatform.http.rest.ResponseType<T> responseType)` Invoke the request using `POST` method with given `entity` request payload and asynchronously receive a response back.
    `default <T> reactor.core.publisher.Mono<T>` | `postForEntity(com.holonplatform.http.rest.RequestEntity<?> entity, Class<T> responseType)` Invoke the request using `POST` method with given `entity` request payload and asynchronously receive the response payload back.
    `default <T> reactor.core.publisher.Mono<T>` | `postForEntity(com.holonplatform.http.rest.RequestEntity<?> entity, com.holonplatform.http.rest.ResponseType<T> responseType)` Invoke the request using `POST` method with given `entity` request payload and asynchronously receive the response payload back.
    `default reactor.core.publisher.Mono<URI>` | `postForLocation(com.holonplatform.http.rest.RequestEntity<?> entity)` Invoke the request using `POST` method with given `entity` request payload and asynchronously receive the value of the `LOCATION` header back, if present.
    `default reactor.core.publisher.Mono<ReactiveResponseEntity<Void>>` | `put(com.holonplatform.http.rest.RequestEntity<?> entity)` Invoke the request using `PUT` method with given `entity` request payload and asynchronously receive a response back.
    `default <T> reactor.core.publisher.Mono<ReactiveResponseEntity<T>>` | `put(com.holonplatform.http.rest.RequestEntity<?> entity, Class<T> responseType)` Invoke the request using `PUT` method with given `entity` request payload and asynchronously receive a response back.
    `default <T> reactor.core.publisher.Mono<ReactiveResponseEntity<T>>` | `put(com.holonplatform.http.rest.RequestEntity<?> entity, com.holonplatform.http.rest.ResponseType<T> responseType)` Invoke the request using `PUT` method with given `entity` request payload and asynchronously receive a response back.
    `default <T> reactor.core.publisher.Mono<T>` | `putForEntity(com.holonplatform.http.rest.RequestEntity<?> entity, Class<T> responseType)` Invoke the request using `PUT` method with given `entity` request payload and asynchronously receive the response entity payload back.
    `default <T> reactor.core.publisher.Mono<T>` | `putForEntity(com.holonplatform.http.rest.RequestEntity<?> entity, com.holonplatform.http.rest.ResponseType<T> responseType)` Invoke the request using `PUT` method with given `entity` request entity payload and asynchronously receive the response payload back.
    `default reactor.core.publisher.Mono<ReactiveResponseEntity<Void>>` | `trace()` Invoke the request using `TRACE` method and asynchronously receive a response back.
    `default <T> reactor.core.publisher.Mono<ReactiveResponseEntity<T>>` | `trace(Class<T> responseType)` Invoke the request using `TRACE` method and asynchronously receive a response back.
    `default <T> reactor.core.publisher.Mono<ReactiveResponseEntity<T>>` | `trace(com.holonplatform.http.rest.ResponseType<T> responseType)` Invoke the request using `TRACE` method and asynchronously receive a response back.
    `default <T> reactor.core.publisher.Mono<T>` | `traceForEntity(Class<T> responseType)` Invoke the request using `TRACE` method and asynchronously receive the response entity payload back.
    `default <T> reactor.core.publisher.Mono<T>` | `traceForEntity(com.holonplatform.http.rest.ResponseType<T> responseType)` Invoke the request using `TRACE` method and asynchronously receive the response entity payload of given generic type back.

- - ### Method Detail

    - #### invoke

          <T,R> reactor.core.publisher.Mono<ReactiveResponseEntity<T>> invoke(com.holonplatform.http.HttpMethod method,
                                                                              com.holonplatform.http.rest.RequestEntity<R> requestEntity,
                                                                              com.holonplatform.http.rest.ResponseType<T> responseType)

      Invoke the request and asynchronously receive a response back.

      The response payload is processed and possibly converted by concrete client implementation.

      Specified by:
        `invoke` in interface `com.holonplatform.http.rest.RestClientOperations.InvocationOperations<reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<InputStream>,reactor.core.publisher.Flux<?>,reactor.core.publisher.Mono<URI>>`
      Type Parameters:
        `T` - Response type
        `R` - Request entity type
      Parameters:
        `method` - Request method
        `requestEntity` - Request entity
        `responseType` - Expected response payload type
      Returns:
        A `Mono` to handle the `ReactiveResponseEntity` object as the result of the request invocation
      Throws:
        `com.holonplatform.http.exceptions.HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)

    - #### invokeForSuccess

          <T,R> reactor.core.publisher.Mono<ReactiveResponseEntity<T>> invokeForSuccess(com.holonplatform.http.HttpMethod method,
                                                                                        com.holonplatform.http.rest.RequestEntity<R> requestEntity,
                                                                                        com.holonplatform.http.rest.ResponseType<T> responseType)

      Invoke the request and asynchronously receive a response back only if the response has a success (`2xx`) status code.
      Specified by:
        `invokeForSuccess` in interface `com.holonplatform.http.rest.RestClientOperations.InvocationOperations<reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<InputStream>,reactor.core.publisher.Flux<?>,reactor.core.publisher.Mono<URI>>`
      Type Parameters:
        `T` - Response type
        `R` - Request entity type
      Parameters:
        `method` - Request method
        `requestEntity` - Request entity
        `responseType` - Expected response payload type
      Returns:
        A `Mono` to handle the `ReactiveResponseEntity` object as a result of the request invocation
      Throws:
        `com.holonplatform.http.exceptions.HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `com.holonplatform.http.exceptions.UnsuccessfulResponseException` - In case the status code of the response returned by the server is not a successful type status code, i.e. it is not a `2xx` status code

    - #### invokeForEntity

          <T,R> reactor.core.publisher.Mono<T> invokeForEntity(com.holonplatform.http.HttpMethod method,
                                                               com.holonplatform.http.rest.RequestEntity<R> requestEntity,
                                                               com.holonplatform.http.rest.ResponseType<T> responseType)

      Invoke the request and asynchronously receive back the response content entity.
      Specified by:
        `invokeForEntity` in interface `com.holonplatform.http.rest.RestClientOperations.InvocationOperations<reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<InputStream>,reactor.core.publisher.Flux<?>,reactor.core.publisher.Mono<URI>>`
      Type Parameters:
        `T` - Response type
        `R` - Request entity type
      Parameters:
        `method` - Request method
        `requestEntity` - Request entity
        `responseType` - Expected response payload type
      Returns:
        A `Mono` to handle the response payload of expected type as the result of the request invocation, or an empty Optional if not present (empty response entity)
      Throws:
        `com.holonplatform.http.exceptions.HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `com.holonplatform.http.exceptions.UnsuccessfulResponseException` - In case the status code of the response returned by the server is not a successful type status code, i.e. it is not a `2xx` status code

    - #### invokeForFlux

          <T,R> reactor.core.publisher.Flux<T> invokeForFlux(com.holonplatform.http.HttpMethod method,
                                                             com.holonplatform.http.rest.RequestEntity<R> requestEntity,
                                                             Class<T> responseElementType)

      Invoke the request and asynchronously receive back the response as a `Flux` of response entity elements.
      Type Parameters:
        `T` - Response type
        `R` - Request entity type
      Parameters:
        `method` - Request method
        `requestEntity` - Request entity
        `responseElementType` - Expected response entity elements type
      Returns:
        A `Flux` to handle the response payload elements
      Throws:
        `com.holonplatform.http.exceptions.HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `com.holonplatform.http.exceptions.UnsuccessfulResponseException` - In case the status code of the response returned by the server is not a successful type status code, i.e. it is not a `2xx` status code

    - #### invokeForStream

          <R> reactor.core.publisher.Mono<InputStream> invokeForStream(com.holonplatform.http.HttpMethod method,
                                                                       com.holonplatform.http.rest.RequestEntity<R> requestEntity)

      Invoke the request and asynchronously receive back the response as a raw `InputStream`.
      Type Parameters:
        `R` - Request entity type
      Parameters:
        `method` - Request method
        `requestEntity` - Request entity
      Returns:
        A `Mono` to handle the response payload stream * @throws HttpClientInvocationException Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
      Throws:
        `com.holonplatform.http.exceptions.UnsuccessfulResponseException` - In case the status code of the response returned by the server is not a successful type status code, i.e. it is not a `2xx` status code

    - #### get

          default <T> reactor.core.publisher.Mono<ReactiveResponseEntity<T>> get(Class<T> responseType)

      Invoke the request using `GET` method and asynchronously receive a response back.
      Specified by:
        `get` in interface `com.holonplatform.http.rest.RestClientOperations.InvocationOperations<reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<InputStream>,reactor.core.publisher.Flux<?>,reactor.core.publisher.Mono<URI>>`
      Type Parameters:
        `T` - Response type
      Parameters:
        `responseType` - Expected response payload type
      Returns:
        A `Mono` to handle the `ReactiveResponseEntity` object as a result of the request invocation
      Throws:
        `com.holonplatform.http.exceptions.HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)

    - #### get

          default <T> reactor.core.publisher.Mono<ReactiveResponseEntity<T>> get(com.holonplatform.http.rest.ResponseType<T> responseType)

      Invoke the request using `GET` method and asynchronously receive a response back.
      Specified by:
        `get` in interface `com.holonplatform.http.rest.RestClientOperations.InvocationOperations<reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<InputStream>,reactor.core.publisher.Flux<?>,reactor.core.publisher.Mono<URI>>`
      Type Parameters:
        `T` - Response type
      Parameters:
        `responseType` - Expected response payload type
      Returns:
        A `Mono` to handle the `ReactiveResponseEntity` object as a result of the request invocation
      Throws:
        `com.holonplatform.http.exceptions.HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)

    - #### getForEntity

          default <T> reactor.core.publisher.Mono<T> getForEntity(Class<T> responseType)

      Invoke the request using `GET` method and asynchronously receive the response entity payload back.
      Specified by:
        `getForEntity` in interface `com.holonplatform.http.rest.RestClientOperations.InvocationOperations<reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<InputStream>,reactor.core.publisher.Flux<?>,reactor.core.publisher.Mono<URI>>`
      Type Parameters:
        `T` - Response entity type
      Parameters:
        `responseType` - Expected response payload type
      Returns:
        A `Mono` to handle the response payload of expected type as the result of the request invocation, or an empty Optional if not present (empty response entity)
      Throws:
        `com.holonplatform.http.exceptions.HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `com.holonplatform.http.exceptions.UnsuccessfulResponseException` - In case the status code of the response returned by the server is not a successful type status code, i.e. it is not a `2xx` status code

    - #### getForEntity

          default <T> reactor.core.publisher.Mono<T> getForEntity(com.holonplatform.http.rest.ResponseType<T> responseType)

      Invoke the request using `GET` method and asynchronously receive the response entity payload of given generic type back.
      Specified by:
        `getForEntity` in interface `com.holonplatform.http.rest.RestClientOperations.InvocationOperations<reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<InputStream>,reactor.core.publisher.Flux<?>,reactor.core.publisher.Mono<URI>>`
      Type Parameters:
        `T` - Response entity type
      Parameters:
        `responseType` - Response payload generic type representation
      Returns:
        A `Mono` to handle the response payload of expected type as the result of the request invocation, or an empty Optional if not present (empty response entity)
      Throws:
        `com.holonplatform.http.exceptions.HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `com.holonplatform.http.exceptions.UnsuccessfulResponseException` - In case the status code of the response returned by the server is not a successful type status code, i.e. it is not a `2xx` status code

    - #### getForStream

          default reactor.core.publisher.Mono<InputStream> getForStream()

      Invoke the request using `GET` method and asynchronously receive the response entity `InputStream` back.
      Specified by:
        `getForStream` in interface `com.holonplatform.http.rest.RestClientOperations.InvocationOperations<reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<InputStream>,reactor.core.publisher.Flux<?>,reactor.core.publisher.Mono<URI>>`
      Returns:
        A `Mono` to handle the response payload `InputStream`, or an empty stream for empty responses
      Throws:
        `com.holonplatform.http.exceptions.HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `com.holonplatform.http.exceptions.UnsuccessfulResponseException` - In case the status code of the response returned by the server is not a successful type status code, i.e. it is not a `2xx` status code

    - #### getAsList

          default <T> reactor.core.publisher.Flux<T> getAsList(Class<T> responseType)

      Convenience method to invoke the request using `GET` method and asynchronously receive a response entity payload of `List` type back.
      Specified by:
        `getAsList` in interface `com.holonplatform.http.rest.RestClientOperations.InvocationOperations<reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<InputStream>,reactor.core.publisher.Flux<?>,reactor.core.publisher.Mono<URI>>`
      Type Parameters:
        `T` - Response entity type
      Parameters:
        `responseType` - Expected `List` response type
      Returns:
        A `Flux` to handle the response payload of expected type as the result of the request invocation, or an empty flux if not present
      Throws:
        `com.holonplatform.http.exceptions.HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `com.holonplatform.http.exceptions.UnsuccessfulResponseException` - In case the status code of the response returned by the server is not a successful type status code, i.e. it is not a `2xx` status code

    - #### post

          default reactor.core.publisher.Mono<ReactiveResponseEntity<Void>> post(com.holonplatform.http.rest.RequestEntity<?> entity)

      Invoke the request using `POST` method with given `entity` request payload and asynchronously receive a response back.

      The response type is conventionally of `Void` type, because no response paylod is expected from this invocation. Refer to the other `post` methods to obtain a response payload.

      Specified by:
        `post` in interface `com.holonplatform.http.rest.RestClientOperations.InvocationOperations<reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<InputStream>,reactor.core.publisher.Flux<?>,reactor.core.publisher.Mono<URI>>`
      Parameters:
        `entity` - Request payload
      Returns:
        A `Mono` to handle the `ReactiveResponseEntity` object as a result of the request invocation
      Throws:
        `com.holonplatform.http.exceptions.HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)

    - #### post

          default <T> reactor.core.publisher.Mono<ReactiveResponseEntity<T>> post(com.holonplatform.http.rest.RequestEntity<?> entity,
                                                                                  Class<T> responseType)

      Invoke the request using `POST` method with given `entity` request payload and asynchronously receive a response back.
      Specified by:
        `post` in interface `com.holonplatform.http.rest.RestClientOperations.InvocationOperations<reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<InputStream>,reactor.core.publisher.Flux<?>,reactor.core.publisher.Mono<URI>>`
      Type Parameters:
        `T` - Response type
      Parameters:
        `entity` - Request payload
        `responseType` - Expected response payload type
      Returns:
        A `Mono` to handle the `ReactiveResponseEntity` object as a result of the request invocation
      Throws:
        `com.holonplatform.http.exceptions.HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)

    - #### post

          default <T> reactor.core.publisher.Mono<ReactiveResponseEntity<T>> post(com.holonplatform.http.rest.RequestEntity<?> entity,
                                                                                  com.holonplatform.http.rest.ResponseType<T> responseType)

      Invoke the request using `POST` method with given `entity` request payload and asynchronously receive a response back.
      Specified by:
        `post` in interface `com.holonplatform.http.rest.RestClientOperations.InvocationOperations<reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<InputStream>,reactor.core.publisher.Flux<?>,reactor.core.publisher.Mono<URI>>`
      Type Parameters:
        `T` - Response type
      Parameters:
        `entity` - Request payload
        `responseType` - Expected response payload type
      Returns:
        A `Mono` to handle the `ReactiveResponseEntity` object as a result of the request invocation
      Throws:
        `com.holonplatform.http.exceptions.HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)

    - #### postForEntity

          default <T> reactor.core.publisher.Mono<T> postForEntity(com.holonplatform.http.rest.RequestEntity<?> entity,
                                                                   Class<T> responseType)

      Invoke the request using `POST` method with given `entity` request payload and asynchronously receive the response payload back.
      Specified by:
        `postForEntity` in interface `com.holonplatform.http.rest.RestClientOperations.InvocationOperations<reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<InputStream>,reactor.core.publisher.Flux<?>,reactor.core.publisher.Mono<URI>>`
      Type Parameters:
        `T` - Response type
      Parameters:
        `entity` - Request payload
        `responseType` - Expected response payload type
      Returns:
        A `Mono` to handle the response payload of expected type as the result of the request invocation, or an empty Optional if not present (empty response entity)
      Throws:
        `com.holonplatform.http.exceptions.HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `com.holonplatform.http.exceptions.UnsuccessfulResponseException` - In case the status code of the response returned by the server is not a successful type status code, i.e. it is not a `2xx` status code

    - #### postForEntity

          default <T> reactor.core.publisher.Mono<T> postForEntity(com.holonplatform.http.rest.RequestEntity<?> entity,
                                                                   com.holonplatform.http.rest.ResponseType<T> responseType)

      Invoke the request using `POST` method with given `entity` request payload and asynchronously receive the response payload back.
      Specified by:
        `postForEntity` in interface `com.holonplatform.http.rest.RestClientOperations.InvocationOperations<reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<InputStream>,reactor.core.publisher.Flux<?>,reactor.core.publisher.Mono<URI>>`
      Type Parameters:
        `T` - Response type
      Parameters:
        `entity` - Request payload
        `responseType` - Expected response payload type
      Returns:
        A `Mono` to handle the response payload of expected type as the result of the request invocation, or an empty Optional if not present (empty response entity)
      Throws:
        `com.holonplatform.http.exceptions.HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `com.holonplatform.http.exceptions.UnsuccessfulResponseException` - In case the status code of the response returned by the server is not a successful type status code, i.e. it is not a `2xx` status code

    - #### postForLocation

          default reactor.core.publisher.Mono<URI> postForLocation(com.holonplatform.http.rest.RequestEntity<?> entity)

      Invoke the request using `POST` method with given `entity` request payload and asynchronously receive the value of the `LOCATION` header back, if present.
      Specified by:
        `postForLocation` in interface `com.holonplatform.http.rest.RestClientOperations.InvocationOperations<reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<InputStream>,reactor.core.publisher.Flux<?>,reactor.core.publisher.Mono<URI>>`
      Parameters:
        `entity` - Request payload
      Returns:
        A `Mono` to handle the value of the `LOCATION` header back, if present
      Throws:
        `com.holonplatform.http.exceptions.HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `com.holonplatform.http.exceptions.UnsuccessfulResponseException` - In case the status code of the response returned by the server is not a successful type status code, i.e. it is not a `2xx` status code

    - #### put

          default reactor.core.publisher.Mono<ReactiveResponseEntity<Void>> put(com.holonplatform.http.rest.RequestEntity<?> entity)

      Invoke the request using `PUT` method with given `entity` request payload and asynchronously receive a response back.

      The response type is conventionally of `Void` type, because no response paylod is expected from this invocation. Refer to the other `post` methods to obtain a response payload.

      Specified by:
        `put` in interface `com.holonplatform.http.rest.RestClientOperations.InvocationOperations<reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<InputStream>,reactor.core.publisher.Flux<?>,reactor.core.publisher.Mono<URI>>`
      Parameters:
        `entity` - Request payload
      Returns:
        A `Mono` to handle the `ReactiveResponseEntity` object as a result of the request invocation
      Throws:
        `com.holonplatform.http.exceptions.HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)

    - #### put

          default <T> reactor.core.publisher.Mono<ReactiveResponseEntity<T>> put(com.holonplatform.http.rest.RequestEntity<?> entity,
                                                                                 Class<T> responseType)

      Invoke the request using `PUT` method with given `entity` request payload and asynchronously receive a response back.
      Specified by:
        `put` in interface `com.holonplatform.http.rest.RestClientOperations.InvocationOperations<reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<InputStream>,reactor.core.publisher.Flux<?>,reactor.core.publisher.Mono<URI>>`
      Type Parameters:
        `T` - Response type
      Parameters:
        `entity` - Request payload
        `responseType` - Expected response payload type
      Returns:
        A `Mono` to handle the `ReactiveResponseEntity` object as a result of the request invocation
      Throws:
        `com.holonplatform.http.exceptions.HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)

    - #### put

          default <T> reactor.core.publisher.Mono<ReactiveResponseEntity<T>> put(com.holonplatform.http.rest.RequestEntity<?> entity,
                                                                                 com.holonplatform.http.rest.ResponseType<T> responseType)

      Invoke the request using `PUT` method with given `entity` request payload and asynchronously receive a response back.
      Specified by:
        `put` in interface `com.holonplatform.http.rest.RestClientOperations.InvocationOperations<reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<InputStream>,reactor.core.publisher.Flux<?>,reactor.core.publisher.Mono<URI>>`
      Type Parameters:
        `T` - Response type
      Parameters:
        `entity` - Request payload
        `responseType` - Expected response payload type
      Returns:
        A `Mono` to handle the `ReactiveResponseEntity` object as a result of the request invocation
      Throws:
        `com.holonplatform.http.exceptions.HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)

    - #### putForEntity

          default <T> reactor.core.publisher.Mono<T> putForEntity(com.holonplatform.http.rest.RequestEntity<?> entity,
                                                                  Class<T> responseType)

      Invoke the request using `PUT` method with given `entity` request payload and asynchronously receive the response entity payload back.
      Specified by:
        `putForEntity` in interface `com.holonplatform.http.rest.RestClientOperations.InvocationOperations<reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<InputStream>,reactor.core.publisher.Flux<?>,reactor.core.publisher.Mono<URI>>`
      Type Parameters:
        `T` - Response entity type
      Parameters:
        `entity` - Request payload
        `responseType` - Expected response payload type
      Returns:
        A `Mono` to handle the response payload of expected type as the result of the request invocation, or an empty Optional if not present (empty response entity)
      Throws:
        `com.holonplatform.http.exceptions.HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `com.holonplatform.http.exceptions.UnsuccessfulResponseException` - In case the status code of the response returned by the server is not a successful type status code, i.e. it is not a `2xx` status code

    - #### putForEntity

          default <T> reactor.core.publisher.Mono<T> putForEntity(com.holonplatform.http.rest.RequestEntity<?> entity,
                                                                  com.holonplatform.http.rest.ResponseType<T> responseType)

      Invoke the request using `PUT` method with given `entity` request entity payload and asynchronously receive the response payload back.
      Specified by:
        `putForEntity` in interface `com.holonplatform.http.rest.RestClientOperations.InvocationOperations<reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<InputStream>,reactor.core.publisher.Flux<?>,reactor.core.publisher.Mono<URI>>`
      Type Parameters:
        `T` - Response entity type
      Parameters:
        `entity` - Request payload
        `responseType` - Expected response payload type
      Returns:
        A `Mono` to handle the response payload of expected type as the result of the request invocation, or an empty Optional if not present (empty response entity)
      Throws:
        `com.holonplatform.http.exceptions.HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `com.holonplatform.http.exceptions.UnsuccessfulResponseException` - In case the status code of the response returned by the server is not a successful type status code, i.e. it is not a `2xx` status code

    - #### patch

          default reactor.core.publisher.Mono<ReactiveResponseEntity<Void>> patch(com.holonplatform.http.rest.RequestEntity<?> entity)

      Invoke the request using `PATCH` method with given `entity` request payload and asynchronously receive a response back.

      The response type is conventionally of `Void` type, because no response paylod is expected from this invocation. Refer to the other `post` methods to obtain a response payload.

      Specified by:
        `patch` in interface `com.holonplatform.http.rest.RestClientOperations.InvocationOperations<reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<InputStream>,reactor.core.publisher.Flux<?>,reactor.core.publisher.Mono<URI>>`
      Parameters:
        `entity` - Request payload
      Returns:
        A `Mono` to handle the `ReactiveResponseEntity` object as a result of the request invocation
      Throws:
        `com.holonplatform.http.exceptions.HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)

    - #### patch

          default <T> reactor.core.publisher.Mono<ReactiveResponseEntity<T>> patch(com.holonplatform.http.rest.RequestEntity<?> entity,
                                                                                   Class<T> responseType)

      Invoke the request using `PATCH` method with given `entity` request payload and asynchronously receive a response back.
      Specified by:
        `patch` in interface `com.holonplatform.http.rest.RestClientOperations.InvocationOperations<reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<InputStream>,reactor.core.publisher.Flux<?>,reactor.core.publisher.Mono<URI>>`
      Type Parameters:
        `T` - Response type
      Parameters:
        `entity` - Request payload
        `responseType` - Expected response payload type
      Returns:
        A `Mono` to handle the `ReactiveResponseEntity` object as a result of the request invocation
      Throws:
        `com.holonplatform.http.exceptions.HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `com.holonplatform.http.exceptions.UnsuccessfulResponseException` - In case the status code of the response returned by the server is not a successful type status code, i.e. it is not a `2xx` status code

    - #### patch

          default <T> reactor.core.publisher.Mono<ReactiveResponseEntity<T>> patch(com.holonplatform.http.rest.RequestEntity<?> entity,
                                                                                   com.holonplatform.http.rest.ResponseType<T> responseType)

      Invoke the request using `PATCH` method with given `entity` request payload and asynchronously receive a response back.
      Specified by:
        `patch` in interface `com.holonplatform.http.rest.RestClientOperations.InvocationOperations<reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<InputStream>,reactor.core.publisher.Flux<?>,reactor.core.publisher.Mono<URI>>`
      Type Parameters:
        `T` - Response type
      Parameters:
        `entity` - Request payload
        `responseType` - Expected response payload type
      Returns:
        A `Mono` to handle the `ReactiveResponseEntity` object as a result of the request invocation
      Throws:
        `com.holonplatform.http.exceptions.HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `com.holonplatform.http.exceptions.UnsuccessfulResponseException` - In case the status code of the response returned by the server is not a successful type status code, i.e. it is not a `2xx` status code

    - #### patchForEntity

          default <T> reactor.core.publisher.Mono<T> patchForEntity(com.holonplatform.http.rest.RequestEntity<?> entity,
                                                                    Class<T> responseType)

      Invoke the request using `PATCH` method with given `entity` request payload and asynchronously receive the response entity payload back.
      Specified by:
        `patchForEntity` in interface `com.holonplatform.http.rest.RestClientOperations.InvocationOperations<reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<InputStream>,reactor.core.publisher.Flux<?>,reactor.core.publisher.Mono<URI>>`
      Type Parameters:
        `T` - Response entity type
      Parameters:
        `entity` - Request payload
        `responseType` - Expected response payload type
      Returns:
        A `Mono` to handle the response payload of expected type as the result of the request invocation, or an empty Optional if not present (empty response entity)
      Throws:
        `com.holonplatform.http.exceptions.HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `com.holonplatform.http.exceptions.UnsuccessfulResponseException` - In case the status code of the response returned by the server is not a successful type status code, i.e. it is not a `2xx` status code

    - #### patchForEntity

          default <T> reactor.core.publisher.Mono<T> patchForEntity(com.holonplatform.http.rest.RequestEntity<?> entity,
                                                                    com.holonplatform.http.rest.ResponseType<T> responseType)

      Invoke the request using `PATCH` method with given `entity` request payload and asynchronously receive the response entity payload back.
      Specified by:
        `patchForEntity` in interface `com.holonplatform.http.rest.RestClientOperations.InvocationOperations<reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<InputStream>,reactor.core.publisher.Flux<?>,reactor.core.publisher.Mono<URI>>`
      Type Parameters:
        `T` - Response entity type
      Parameters:
        `entity` - Request payload
        `responseType` - Expected response payload type
      Returns:
        A `Mono` to handle the response payload of expected type as the result of the request invocation, or an empty Optional if not present (empty response entity)
      Throws:
        `com.holonplatform.http.exceptions.HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `com.holonplatform.http.exceptions.UnsuccessfulResponseException` - In case the status code of the response returned by the server is not a successful type status code, i.e. it is not a `2xx` status code

    - #### delete

          default reactor.core.publisher.Mono<ReactiveResponseEntity<Void>> delete()

      Invoke the request using `DELETE` method and asynchronously receive a response back.

      The response type is conventionally of `Void` type, because no response paylod is expected from this invocation. Refer to the other `post` methods to obtain a response payload.

      Specified by:
        `delete` in interface `com.holonplatform.http.rest.RestClientOperations.InvocationOperations<reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<InputStream>,reactor.core.publisher.Flux<?>,reactor.core.publisher.Mono<URI>>`
      Returns:
        A `Mono` to handle the `ReactiveResponseEntity` object as a result of the request invocation
      Throws:
        `com.holonplatform.http.exceptions.HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel)

    - #### deleteOrFail

          default reactor.core.publisher.Mono<Void> deleteOrFail()

      Invoke the request asynchronously using the `DELETE` method. If the returned response is not a success response (i.e. with a `2xx` status code), a `UnsuccessfulResponseException` is thrown.
      Returns:
        A `Mono` to handle the response
      Throws:
        `com.holonplatform.http.exceptions.HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel)
        `com.holonplatform.http.exceptions.UnsuccessfulResponseException` - In case the status code of the response returned by the server is not a successful type status code, i.e. it is not a `2xx` status code

    - #### delete

          default <T> reactor.core.publisher.Mono<ReactiveResponseEntity<T>> delete(Class<T> responseType)

      Invoke the request asynchronously using the `DELETE` method and receive a response back.
      Specified by:
        `delete` in interface `com.holonplatform.http.rest.RestClientOperations.InvocationOperations<reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<InputStream>,reactor.core.publisher.Flux<?>,reactor.core.publisher.Mono<URI>>`
      Type Parameters:
        `T` - Response type
      Parameters:
        `responseType` - Expected response payload type
      Returns:
        A `Mono` to handle the `ReactiveResponseEntity` object as a result of the request invocation
      Throws:
        `com.holonplatform.http.exceptions.HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)

    - #### delete

          default <T> reactor.core.publisher.Mono<ReactiveResponseEntity<T>> delete(com.holonplatform.http.rest.ResponseType<T> responseType)

      Invoke the request using `DELETE` method and asynchronously receive a response back.
      Specified by:
        `delete` in interface `com.holonplatform.http.rest.RestClientOperations.InvocationOperations<reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<InputStream>,reactor.core.publisher.Flux<?>,reactor.core.publisher.Mono<URI>>`
      Type Parameters:
        `T` - Response type
      Parameters:
        `responseType` - Response payload generic type representation
      Returns:
        A `Mono` to handle the `ReactiveResponseEntity` object as a result of the request invocation
      Throws:
        `com.holonplatform.http.exceptions.HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)

    - #### deleteForEntity

          default <T> reactor.core.publisher.Mono<T> deleteForEntity(Class<T> responseType)

      Invoke the request using `DELETE` method and asynchronously receive the response entity payload back.
      Specified by:
        `deleteForEntity` in interface `com.holonplatform.http.rest.RestClientOperations.InvocationOperations<reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<InputStream>,reactor.core.publisher.Flux<?>,reactor.core.publisher.Mono<URI>>`
      Type Parameters:
        `T` - Response entity type
      Parameters:
        `responseType` - Expected response payload type
      Returns:
        A `Mono` to handle the response payload of expected type as the result of the request invocation, or an empty Optional if not present (empty response entity)
      Throws:
        `com.holonplatform.http.exceptions.HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `com.holonplatform.http.exceptions.UnsuccessfulResponseException` - In case the status code of the response returned by the server is not a successful type status code, i.e. it is not a `2xx` status code

    - #### deleteForEntity

          default <T> reactor.core.publisher.Mono<T> deleteForEntity(com.holonplatform.http.rest.ResponseType<T> responseType)

      Invoke the request using `DELETE` method and asynchronously receive the response entity payload of given generic type back.
      Specified by:
        `deleteForEntity` in interface `com.holonplatform.http.rest.RestClientOperations.InvocationOperations<reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<InputStream>,reactor.core.publisher.Flux<?>,reactor.core.publisher.Mono<URI>>`
      Type Parameters:
        `T` - Response entity type
      Parameters:
        `responseType` - Response payload generic type representation
      Returns:
        A `Mono` to handle the response payload of expected type as the result of the request invocation, or an empty Optional if not present (empty response entity)
      Throws:
        `com.holonplatform.http.exceptions.HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `com.holonplatform.http.exceptions.UnsuccessfulResponseException` - In case the status code of the response returned by the server is not a successful type status code, i.e. it is not a `2xx` status code

    - #### options

          default reactor.core.publisher.Mono<ReactiveResponseEntity<Void>> options()

      Invoke the request using `OPTIONS` method and asynchronously receive a response back.

      The response type is conventionally of `Void` type, because no response paylod is expected from this invocation. Refer to the other `post` methods to obtain a response payload.

      Specified by:
        `options` in interface `com.holonplatform.http.rest.RestClientOperations.InvocationOperations<reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<InputStream>,reactor.core.publisher.Flux<?>,reactor.core.publisher.Mono<URI>>`
      Returns:
        A `Mono` to handle the `ReactiveResponseEntity` object as a result of the request invocation
      Throws:
        `com.holonplatform.http.exceptions.HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel)

    - #### options

          default <T> reactor.core.publisher.Mono<ReactiveResponseEntity<T>> options(Class<T> responseType)

      Invoke the request using `OPTIONS` method and asynchronously receive a response back.
      Specified by:
        `options` in interface `com.holonplatform.http.rest.RestClientOperations.InvocationOperations<reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<InputStream>,reactor.core.publisher.Flux<?>,reactor.core.publisher.Mono<URI>>`
      Type Parameters:
        `T` - Response type
      Parameters:
        `responseType` - Expected response payload type
      Returns:
        A `Mono` to handle the `ReactiveResponseEntity` object as a result of the request invocation
      Throws:
        `com.holonplatform.http.exceptions.HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)

    - #### options

          default <T> reactor.core.publisher.Mono<ReactiveResponseEntity<T>> options(com.holonplatform.http.rest.ResponseType<T> responseType)

      Invoke the request using `OPTIONS` method and asynchronously receive a response back.
      Specified by:
        `options` in interface `com.holonplatform.http.rest.RestClientOperations.InvocationOperations<reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<InputStream>,reactor.core.publisher.Flux<?>,reactor.core.publisher.Mono<URI>>`
      Type Parameters:
        `T` - Response type
      Parameters:
        `responseType` - Response payload generic type representation
      Returns:
        A `Mono` to handle the `ReactiveResponseEntity` object as a result of the request invocation
      Throws:
        `com.holonplatform.http.exceptions.HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)

    - #### optionsForEntity

          default <T> reactor.core.publisher.Mono<T> optionsForEntity(Class<T> responseType)

      Invoke the request using `OPTIONS` method and asynchronously receive the response entity payload back.
      Specified by:
        `optionsForEntity` in interface `com.holonplatform.http.rest.RestClientOperations.InvocationOperations<reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<InputStream>,reactor.core.publisher.Flux<?>,reactor.core.publisher.Mono<URI>>`
      Type Parameters:
        `T` - Response entity type
      Parameters:
        `responseType` - Expected response payload type
      Returns:
        A `Mono` to handle the response payload of expected type as the result of the request invocation, or an empty Optional if not present (empty response entity)
      Throws:
        `com.holonplatform.http.exceptions.HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `com.holonplatform.http.exceptions.UnsuccessfulResponseException` - In case the status code of the response returned by the server is not a successful type status code, i.e. it is not a `2xx` status code

    - #### optionsForEntity

          default <T> reactor.core.publisher.Mono<T> optionsForEntity(com.holonplatform.http.rest.ResponseType<T> responseType)

      Invoke the request using `OPTIONS` method and asynchronously receive the response entity payload of given generic type back.
      Specified by:
        `optionsForEntity` in interface `com.holonplatform.http.rest.RestClientOperations.InvocationOperations<reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<InputStream>,reactor.core.publisher.Flux<?>,reactor.core.publisher.Mono<URI>>`
      Type Parameters:
        `T` - Response entity type
      Parameters:
        `responseType` - Response payload generic type representation
      Returns:
        A `Mono` to handle the response payload of expected type as the result of the request invocation, or an empty Optional if not present (empty response entity)
      Throws:
        `com.holonplatform.http.exceptions.HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `com.holonplatform.http.exceptions.UnsuccessfulResponseException` - In case the status code of the response returned by the server is not a successful type status code, i.e. it is not a `2xx` status code

    - #### trace

          default reactor.core.publisher.Mono<ReactiveResponseEntity<Void>> trace()

      Invoke the request using `TRACE` method and asynchronously receive a response back.

      The response type is conventionally of `Void` type, because no response paylod is expected from this invocation. Refer to the other `post` methods to obtain a response payload.

      Specified by:
        `trace` in interface `com.holonplatform.http.rest.RestClientOperations.InvocationOperations<reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<InputStream>,reactor.core.publisher.Flux<?>,reactor.core.publisher.Mono<URI>>`
      Returns:
        A `Mono` to handle the `ReactiveResponseEntity` object as a result of the request invocation
      Throws:
        `com.holonplatform.http.exceptions.HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)

    - #### trace

          default <T> reactor.core.publisher.Mono<ReactiveResponseEntity<T>> trace(Class<T> responseType)

      Invoke the request using `TRACE` method and asynchronously receive a response back.
      Specified by:
        `trace` in interface `com.holonplatform.http.rest.RestClientOperations.InvocationOperations<reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<InputStream>,reactor.core.publisher.Flux<?>,reactor.core.publisher.Mono<URI>>`
      Type Parameters:
        `T` - Response type
      Parameters:
        `responseType` - Expected response payload type
      Returns:
        A `Mono` to handle the `ReactiveResponseEntity` object as a result of the request invocation
      Throws:
        `com.holonplatform.http.exceptions.HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)

    - #### trace

          default <T> reactor.core.publisher.Mono<ReactiveResponseEntity<T>> trace(com.holonplatform.http.rest.ResponseType<T> responseType)

      Invoke the request using `TRACE` method and asynchronously receive a response back.
      Specified by:
        `trace` in interface `com.holonplatform.http.rest.RestClientOperations.InvocationOperations<reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<InputStream>,reactor.core.publisher.Flux<?>,reactor.core.publisher.Mono<URI>>`
      Type Parameters:
        `T` - Response type
      Parameters:
        `responseType` - Response payload generic type representation
      Returns:
        A `Mono` to handle the `ReactiveResponseEntity` object as a result of the request invocation
      Throws:
        `com.holonplatform.http.exceptions.HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)

    - #### traceForEntity

          default <T> reactor.core.publisher.Mono<T> traceForEntity(Class<T> responseType)

      Invoke the request using `TRACE` method and asynchronously receive the response entity payload back.
      Specified by:
        `traceForEntity` in interface `com.holonplatform.http.rest.RestClientOperations.InvocationOperations<reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<InputStream>,reactor.core.publisher.Flux<?>,reactor.core.publisher.Mono<URI>>`
      Type Parameters:
        `T` - Response entity type
      Parameters:
        `responseType` - Expected response payload type
      Returns:
        A `Mono` to handle the response payload of expected type as the result of the request invocation, or an empty Optional if not present (empty response entity)
      Throws:
        `com.holonplatform.http.exceptions.HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `com.holonplatform.http.exceptions.UnsuccessfulResponseException` - In case the status code of the response returned by the server is not a successful type status code, i.e. it is not a `2xx` status code

    - #### traceForEntity

          default <T> reactor.core.publisher.Mono<T> traceForEntity(com.holonplatform.http.rest.ResponseType<T> responseType)

      Invoke the request using `TRACE` method and asynchronously receive the response entity payload of given generic type back.
      Specified by:
        `traceForEntity` in interface `com.holonplatform.http.rest.RestClientOperations.InvocationOperations<reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<InputStream>,reactor.core.publisher.Flux<?>,reactor.core.publisher.Mono<URI>>`
      Type Parameters:
        `T` - Response entity type
      Parameters:
        `responseType` - Response payload generic type representation
      Returns:
        A `Mono` to handle the response payload of expected type as the result of the request invocation, or an empty Optional if not present (empty response entity)
      Throws:
        `com.holonplatform.http.exceptions.HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `com.holonplatform.http.exceptions.UnsuccessfulResponseException` - In case the status code of the response returned by the server is not a successful type status code, i.e. it is not a `2xx` status code

    - #### head

          default reactor.core.publisher.Mono<ReactiveResponseEntity<Void>> head()

      Invoke the request using `HEAD` method and asynchronously receive a response back.
      Specified by:
        `head` in interface `com.holonplatform.http.rest.RestClientOperations.InvocationOperations<reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<?>,reactor.core.publisher.Mono<InputStream>,reactor.core.publisher.Flux<?>,reactor.core.publisher.Mono<URI>>`
      Returns:
        A `Mono` to handle the `ReactiveResponseEntity` object as a result of the request invocation
      Throws:
        `com.holonplatform.http.exceptions.HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)

Copyright © 2019 The Holon Platform. All rights reserved.