com.holonplatform.http.rest

## Interface RestClient.Invocation

- All Superinterfaces:
    RestClientOperations.InvocationOperations<ResponseEntity<?>,Optional<?>,InputStream,List<?>,Optional<URI>>
  All Known Subinterfaces:
    RestClient.RequestDefinition
  Enclosing interface:
    RestClient

      public static interface RestClient.Invocation
      extends RestClientOperations.InvocationOperations<ResponseEntity<?>,Optional<?>,InputStream,List<?>,Optional<URI>>

  Invocation operations

- - ### Method Summary

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

- - ### Method Detail

    - #### invoke

          <T,R> ResponseEntity<T> invoke(HttpMethod method,
                                         RequestEntity<R> requestEntity,
                                         ResponseType<T> responseType)

      Invoke the request and receive a response back.

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

      Specified by:
        `invoke` in interface `RestClientOperations.InvocationOperations<ResponseEntity<?>,Optional<?>,InputStream,List<?>,Optional<URI>>`
      Type Parameters:
        `T` - Response type
        `R` - Request entity type
      Parameters:
        `method` - Request method
        `requestEntity` - Request entity
        `responseType` - Expected response payload type
      Returns:
        the `ResponseEntity` object as a result of the request invocation
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)

    - #### invokeForSuccess

          <T,R> ResponseEntity<T> invokeForSuccess(HttpMethod method,
                                                   RequestEntity<R> requestEntity,
                                                   ResponseType<T> responseType)

      Invoke the request and receive a response back only if the response has a success (`2xx`) status code.
      Specified by:
        `invokeForSuccess` in interface `RestClientOperations.InvocationOperations<ResponseEntity<?>,Optional<?>,InputStream,List<?>,Optional<URI>>`
      Type Parameters:
        `T` - Response type
        `R` - Request entity type
      Parameters:
        `method` - Request method
        `requestEntity` - Request entity
        `responseType` - Expected response payload type
      Returns:
        the `ResponseEntity` object as a result of the request invocation
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `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> Optional<T> invokeForEntity(HttpMethod method,
                                            RequestEntity<R> requestEntity,
                                            ResponseType<T> responseType)

      Invoke the request and receive back the response content entity.
      Specified by:
        `invokeForEntity` in interface `RestClientOperations.InvocationOperations<ResponseEntity<?>,Optional<?>,InputStream,List<?>,Optional<URI>>`
      Type Parameters:
        `T` - Response type
        `R` - Request entity type
      Parameters:
        `method` - Request method
        `requestEntity` - Request entity
        `responseType` - Expected response payload type
      Returns:
        the response payload of expected type as the result of the request invocation, or an empty Optional if not present (empty response entity)
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `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> ResponseEntity<T> get(Class<T> responseType)

      Invoke the request using `GET` method and receive a response back.
      Specified by:
        `get` in interface `RestClientOperations.InvocationOperations<ResponseEntity<?>,Optional<?>,InputStream,List<?>,Optional<URI>>`
      Type Parameters:
        `T` - Response type
      Parameters:
        `responseType` - Expected response payload type
      Returns:
        `ResponseEntity` object as a result of the request invocation
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)

    - #### get

          default <T> ResponseEntity<T> get(ResponseType<T> responseType)

      Invoke the request using `GET` method and receive a response back.
      Specified by:
        `get` in interface `RestClientOperations.InvocationOperations<ResponseEntity<?>,Optional<?>,InputStream,List<?>,Optional<URI>>`
      Type Parameters:
        `T` - Response type
      Parameters:
        `responseType` - Expected response payload type
      Returns:
        `ResponseEntity` object as a result of the request invocation
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)

    - #### getForEntity

          default <T> Optional<T> getForEntity(Class<T> responseType)

      Invoke the request using `GET` method and receive the response entity payload back.
      Specified by:
        `getForEntity` in interface `RestClientOperations.InvocationOperations<ResponseEntity<?>,Optional<?>,InputStream,List<?>,Optional<URI>>`
      Type Parameters:
        `T` - Response entity type
      Parameters:
        `responseType` - Expected response payload type
      Returns:
        the response payload of expected type as the result of the request invocation, or an empty Optional if not present (empty response entity)
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `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> Optional<T> getForEntity(ResponseType<T> responseType)

      Invoke the request using `GET` method and receive the response entity payload of given generic type back.
      Specified by:
        `getForEntity` in interface `RestClientOperations.InvocationOperations<ResponseEntity<?>,Optional<?>,InputStream,List<?>,Optional<URI>>`
      Type Parameters:
        `T` - Response entity type
      Parameters:
        `responseType` - Response payload generic type representation
      Returns:
        the response payload of expected type as the result of the request invocation, or an empty Optional if not present (empty response entity)
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `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 InputStream getForStream()

      Invoke the request using `GET` method and receive the response entity `InputStream` back.
      Specified by:
        `getForStream` in interface `RestClientOperations.InvocationOperations<ResponseEntity<?>,Optional<?>,InputStream,List<?>,Optional<URI>>`
      Returns:
        the response payload `InputStream`, or an empty stream for empty responses
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `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> List<T> getAsList(Class<T> responseType)

      Convenience method to invoke the request using `GET` method and receive a response entity payload of `List` type back.
      Specified by:
        `getAsList` in interface `RestClientOperations.InvocationOperations<ResponseEntity<?>,Optional<?>,InputStream,List<?>,Optional<URI>>`
      Type Parameters:
        `T` - Response entity type
      Parameters:
        `responseType` - Expected `List` response type
      Returns:
        the response payload of expected type as the result of the request invocation, or an empty List if not present
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `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 ResponseEntity<Void> post(RequestEntity<?> entity)

      Invoke the request using `POST` method with given `entity` request payload and 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 `RestClientOperations.InvocationOperations<ResponseEntity<?>,Optional<?>,InputStream,List<?>,Optional<URI>>`
      Parameters:
        `entity` - Request payload
      Returns:
        `ResponseEntity` object as a result of the request invocation
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)

    - #### post

          default <T> ResponseEntity<T> post(RequestEntity<?> entity,
                                             Class<T> responseType)

      Invoke the request using `POST` method with given `entity` request payload and receive a response back.
      Specified by:
        `post` in interface `RestClientOperations.InvocationOperations<ResponseEntity<?>,Optional<?>,InputStream,List<?>,Optional<URI>>`
      Type Parameters:
        `T` - Response type
      Parameters:
        `entity` - Request payload
        `responseType` - Expected response payload type
      Returns:
        `ResponseEntity` object as a result of the request invocation
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)

    - #### post

          default <T> ResponseEntity<T> post(RequestEntity<?> entity,
                                             ResponseType<T> responseType)

      Invoke the request using `POST` method with given `entity` request payload and receive a response back.
      Specified by:
        `post` in interface `RestClientOperations.InvocationOperations<ResponseEntity<?>,Optional<?>,InputStream,List<?>,Optional<URI>>`
      Type Parameters:
        `T` - Response type
      Parameters:
        `entity` - Request payload
        `responseType` - Expected response payload type
      Returns:
        `ResponseEntity` object as a result of the request invocation
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)

    - #### postForEntity

          default <T> Optional<T> postForEntity(RequestEntity<?> entity,
                                                Class<T> responseType)

      Invoke the request using `POST` method with given `entity` request payload and receive the response payload back.
      Specified by:
        `postForEntity` in interface `RestClientOperations.InvocationOperations<ResponseEntity<?>,Optional<?>,InputStream,List<?>,Optional<URI>>`
      Type Parameters:
        `T` - Response type
      Parameters:
        `entity` - Request payload
        `responseType` - Expected response payload type
      Returns:
        the response payload of expected type as the result of the request invocation, or an empty Optional if not present (empty response entity)
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `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> Optional<T> postForEntity(RequestEntity<?> entity,
                                                ResponseType<T> responseType)

      Invoke the request using `POST` method with given `entity` request payload and receive the response payload back.
      Specified by:
        `postForEntity` in interface `RestClientOperations.InvocationOperations<ResponseEntity<?>,Optional<?>,InputStream,List<?>,Optional<URI>>`
      Type Parameters:
        `T` - Response type
      Parameters:
        `entity` - Request payload
        `responseType` - Expected response payload type
      Returns:
        the response payload of expected type as the result of the request invocation, or an empty Optional if not present (empty response entity)
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `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 Optional<URI> postForLocation(RequestEntity<?> entity)

      Invoke the request using `POST` method with given `entity` request payload and receive the value of the `LOCATION` header back, if present.
      Specified by:
        `postForLocation` in interface `RestClientOperations.InvocationOperations<ResponseEntity<?>,Optional<?>,InputStream,List<?>,Optional<URI>>`
      Parameters:
        `entity` - Request payload
      Returns:
        the value of the `LOCATION` header back, if present
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `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 ResponseEntity<Void> put(RequestEntity<?> entity)

      Invoke the request using `PUT` method with given `entity` request payload and 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 `RestClientOperations.InvocationOperations<ResponseEntity<?>,Optional<?>,InputStream,List<?>,Optional<URI>>`
      Parameters:
        `entity` - Request payload
      Returns:
        `ResponseEntity` object as a result of the request invocation
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)

    - #### put

          default <T> ResponseEntity<T> put(RequestEntity<?> entity,
                                            Class<T> responseType)

      Invoke the request using `PUT` method with given `entity` request payload and receive a response back.
      Specified by:
        `put` in interface `RestClientOperations.InvocationOperations<ResponseEntity<?>,Optional<?>,InputStream,List<?>,Optional<URI>>`
      Type Parameters:
        `T` - Response type
      Parameters:
        `entity` - Request payload
        `responseType` - Expected response payload type
      Returns:
        `ResponseEntity` object as a result of the request invocation
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)

    - #### put

          default <T> ResponseEntity<T> put(RequestEntity<?> entity,
                                            ResponseType<T> responseType)

      Invoke the request using `PUT` method with given `entity` request payload and receive a response back.
      Specified by:
        `put` in interface `RestClientOperations.InvocationOperations<ResponseEntity<?>,Optional<?>,InputStream,List<?>,Optional<URI>>`
      Type Parameters:
        `T` - Response type
      Parameters:
        `entity` - Request payload
        `responseType` - Expected response payload type
      Returns:
        `ResponseEntity` object as a result of the request invocation
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)

    - #### putForEntity

          default <T> Optional<T> putForEntity(RequestEntity<?> entity,
                                               Class<T> responseType)

      Invoke the request using `PUT` method with given `entity` request payload and receive the response entity payload back.
      Specified by:
        `putForEntity` in interface `RestClientOperations.InvocationOperations<ResponseEntity<?>,Optional<?>,InputStream,List<?>,Optional<URI>>`
      Type Parameters:
        `T` - Response entity type
      Parameters:
        `entity` - Request payload
        `responseType` - Expected response payload type
      Returns:
        the response payload of expected type as the result of the request invocation, or an empty Optional if not present (empty response entity)
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `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> Optional<T> putForEntity(RequestEntity<?> entity,
                                               ResponseType<T> responseType)

      Invoke the request using `PUT` method with given `entity` request entity payload and receive the response payload back.
      Specified by:
        `putForEntity` in interface `RestClientOperations.InvocationOperations<ResponseEntity<?>,Optional<?>,InputStream,List<?>,Optional<URI>>`
      Type Parameters:
        `T` - Response entity type
      Parameters:
        `entity` - Request payload
        `responseType` - Expected response payload type
      Returns:
        the response payload of expected type as the result of the request invocation, or an empty Optional if not present (empty response entity)
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `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 ResponseEntity<Void> patch(RequestEntity<?> entity)

      Invoke the request using `PATCH` method with given `entity` request payload and 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 `RestClientOperations.InvocationOperations<ResponseEntity<?>,Optional<?>,InputStream,List<?>,Optional<URI>>`
      Parameters:
        `entity` - Request payload
      Returns:
        `ResponseEntity` object as a result of the request invocation
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)

    - #### patch

          default <T> ResponseEntity<T> patch(RequestEntity<?> entity,
                                              Class<T> responseType)

      Invoke the request using `PATCH` method with given `entity` request payload and receive a response back.
      Specified by:
        `patch` in interface `RestClientOperations.InvocationOperations<ResponseEntity<?>,Optional<?>,InputStream,List<?>,Optional<URI>>`
      Type Parameters:
        `T` - Response type
      Parameters:
        `entity` - Request payload
        `responseType` - Expected response payload type
      Returns:
        `ResponseEntity` object as a result of the request invocation
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `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> ResponseEntity<T> patch(RequestEntity<?> entity,
                                              ResponseType<T> responseType)

      Invoke the request using `PATCH` method with given `entity` request payload and receive a response back.
      Specified by:
        `patch` in interface `RestClientOperations.InvocationOperations<ResponseEntity<?>,Optional<?>,InputStream,List<?>,Optional<URI>>`
      Type Parameters:
        `T` - Response type
      Parameters:
        `entity` - Request payload
        `responseType` - Expected response payload type
      Returns:
        `ResponseEntity` object as a result of the request invocation
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `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> Optional<T> patchForEntity(RequestEntity<?> entity,
                                                 Class<T> responseType)

      Invoke the request using `PATCH` method with given `entity` request payload and receive the response entity payload back.
      Specified by:
        `patchForEntity` in interface `RestClientOperations.InvocationOperations<ResponseEntity<?>,Optional<?>,InputStream,List<?>,Optional<URI>>`
      Type Parameters:
        `T` - Response entity type
      Parameters:
        `entity` - Request payload
        `responseType` - Expected response payload type
      Returns:
        the response payload of expected type as the result of the request invocation, or an empty Optional if not present (empty response entity)
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `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> Optional<T> patchForEntity(RequestEntity<?> entity,
                                                 ResponseType<T> responseType)

      Invoke the request using `PATCH` method with given `entity` request payload and receive the response entity payload back.
      Specified by:
        `patchForEntity` in interface `RestClientOperations.InvocationOperations<ResponseEntity<?>,Optional<?>,InputStream,List<?>,Optional<URI>>`
      Type Parameters:
        `T` - Response entity type
      Parameters:
        `entity` - Request payload
        `responseType` - Expected response payload type
      Returns:
        the response payload of expected type as the result of the request invocation, or an empty Optional if not present (empty response entity)
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `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 ResponseEntity<Void> delete()

      Invoke the request using `DELETE` method and 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 `RestClientOperations.InvocationOperations<ResponseEntity<?>,Optional<?>,InputStream,List<?>,Optional<URI>>`
      Returns:
        `ResponseEntity` object as a result of the request invocation
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel)

    - #### deleteOrFail

          default void deleteOrFail()

      Invoke the request using `DELETE` method. If the returned response is not a success response (i.e. with a `2xx` status code), a `UnsuccessfulResponseException` is thrown.
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel)
        `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> ResponseEntity<T> delete(Class<T> responseType)

      Invoke the request using `DELETE` method and receive a response back.
      Specified by:
        `delete` in interface `RestClientOperations.InvocationOperations<ResponseEntity<?>,Optional<?>,InputStream,List<?>,Optional<URI>>`
      Type Parameters:
        `T` - Response type
      Parameters:
        `responseType` - Expected response payload type
      Returns:
        `ResponseEntity` object as a result of the request invocation
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)

    - #### delete

          default <T> ResponseEntity<T> delete(ResponseType<T> responseType)

      Invoke the request using `DELETE` method and receive a response back.
      Specified by:
        `delete` in interface `RestClientOperations.InvocationOperations<ResponseEntity<?>,Optional<?>,InputStream,List<?>,Optional<URI>>`
      Type Parameters:
        `T` - Response type
      Parameters:
        `responseType` - Response payload generic type representation
      Returns:
        `ResponseEntity` object as a result of the request invocation
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)

    - #### deleteForEntity

          default <T> Optional<T> deleteForEntity(Class<T> responseType)

      Invoke the request using `DELETE` method and receive the response entity payload back.
      Specified by:
        `deleteForEntity` in interface `RestClientOperations.InvocationOperations<ResponseEntity<?>,Optional<?>,InputStream,List<?>,Optional<URI>>`
      Type Parameters:
        `T` - Response entity type
      Parameters:
        `responseType` - Expected response payload type
      Returns:
        the response payload of expected type as the result of the request invocation, or an empty Optional if not present (empty response entity)
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `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> Optional<T> deleteForEntity(ResponseType<T> responseType)

      Invoke the request using `DELETE` method and receive the response entity payload of given generic type back.
      Specified by:
        `deleteForEntity` in interface `RestClientOperations.InvocationOperations<ResponseEntity<?>,Optional<?>,InputStream,List<?>,Optional<URI>>`
      Type Parameters:
        `T` - Response entity type
      Parameters:
        `responseType` - Response payload generic type representation
      Returns:
        the response payload of expected type as the result of the request invocation, or an empty Optional if not present (empty response entity)
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `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 ResponseEntity<Void> options()

      Invoke the request using `OPTIONS` method and 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 `RestClientOperations.InvocationOperations<ResponseEntity<?>,Optional<?>,InputStream,List<?>,Optional<URI>>`
      Returns:
        `ResponseEntity` object as a result of the request invocation
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel)

    - #### options

          default <T> ResponseEntity<T> options(Class<T> responseType)

      Invoke the request using `OPTIONS` method and receive a response back.
      Specified by:
        `options` in interface `RestClientOperations.InvocationOperations<ResponseEntity<?>,Optional<?>,InputStream,List<?>,Optional<URI>>`
      Type Parameters:
        `T` - Response type
      Parameters:
        `responseType` - Expected response payload type
      Returns:
        `ResponseEntity` object as a result of the request invocation
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)

    - #### options

          default <T> ResponseEntity<T> options(ResponseType<T> responseType)

      Invoke the request using `OPTIONS` method and receive a response back.
      Specified by:
        `options` in interface `RestClientOperations.InvocationOperations<ResponseEntity<?>,Optional<?>,InputStream,List<?>,Optional<URI>>`
      Type Parameters:
        `T` - Response type
      Parameters:
        `responseType` - Response payload generic type representation
      Returns:
        `ResponseEntity` object as a result of the request invocation
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)

    - #### optionsForEntity

          default <T> Optional<T> optionsForEntity(Class<T> responseType)

      Invoke the request using `OPTIONS` method and receive the response entity payload back.
      Specified by:
        `optionsForEntity` in interface `RestClientOperations.InvocationOperations<ResponseEntity<?>,Optional<?>,InputStream,List<?>,Optional<URI>>`
      Type Parameters:
        `T` - Response entity type
      Parameters:
        `responseType` - Expected response payload type
      Returns:
        the response payload of expected type as the result of the request invocation, or an empty Optional if not present (empty response entity)
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `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> Optional<T> optionsForEntity(ResponseType<T> responseType)

      Invoke the request using `OPTIONS` method and receive the response entity payload of given generic type back.
      Specified by:
        `optionsForEntity` in interface `RestClientOperations.InvocationOperations<ResponseEntity<?>,Optional<?>,InputStream,List<?>,Optional<URI>>`
      Type Parameters:
        `T` - Response entity type
      Parameters:
        `responseType` - Response payload generic type representation
      Returns:
        the response payload of expected type as the result of the request invocation, or an empty Optional if not present (empty response entity)
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `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 ResponseEntity<Void> trace()

      Invoke the request using `TRACE` method and 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 `RestClientOperations.InvocationOperations<ResponseEntity<?>,Optional<?>,InputStream,List<?>,Optional<URI>>`
      Returns:
        `ResponseEntity` object as a result of the request invocation
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)

    - #### trace

          default <T> ResponseEntity<T> trace(Class<T> responseType)

      Invoke the request using `TRACE` method and receive a response back.
      Specified by:
        `trace` in interface `RestClientOperations.InvocationOperations<ResponseEntity<?>,Optional<?>,InputStream,List<?>,Optional<URI>>`
      Type Parameters:
        `T` - Response type
      Parameters:
        `responseType` - Expected response payload type
      Returns:
        `ResponseEntity` object as a result of the request invocation
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)

    - #### trace

          default <T> ResponseEntity<T> trace(ResponseType<T> responseType)

      Invoke the request using `TRACE` method and receive a response back.
      Specified by:
        `trace` in interface `RestClientOperations.InvocationOperations<ResponseEntity<?>,Optional<?>,InputStream,List<?>,Optional<URI>>`
      Type Parameters:
        `T` - Response type
      Parameters:
        `responseType` - Response payload generic type representation
      Returns:
        `ResponseEntity` object as a result of the request invocation
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)

    - #### traceForEntity

          default <T> Optional<T> traceForEntity(Class<T> responseType)

      Invoke the request using `TRACE` method and receive the response entity payload back.
      Specified by:
        `traceForEntity` in interface `RestClientOperations.InvocationOperations<ResponseEntity<?>,Optional<?>,InputStream,List<?>,Optional<URI>>`
      Type Parameters:
        `T` - Response entity type
      Parameters:
        `responseType` - Expected response payload type
      Returns:
        the response payload of expected type as the result of the request invocation, or an empty Optional if not present (empty response entity)
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `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> Optional<T> traceForEntity(ResponseType<T> responseType)

      Invoke the request using `TRACE` method and receive the response entity payload of given generic type back.
      Specified by:
        `traceForEntity` in interface `RestClientOperations.InvocationOperations<ResponseEntity<?>,Optional<?>,InputStream,List<?>,Optional<URI>>`
      Type Parameters:
        `T` - Response entity type
      Parameters:
        `responseType` - Response payload generic type representation
      Returns:
        the response payload of expected type as the result of the request invocation, or an empty Optional if not present (empty response entity)
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `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 ResponseEntity<Void> head()

      Invoke the request using `HEAD` method and receive a response back.
      Specified by:
        `head` in interface `RestClientOperations.InvocationOperations<ResponseEntity<?>,Optional<?>,InputStream,List<?>,Optional<URI>>`
      Returns:
        `ResponseEntity` object as a result of the request invocation
      Throws:
        `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.