# DaprClientHttp (dapr-sdk-parent 1.10.0 API)

Package io.dapr.client

## Class DaprClientHttp

- java.lang.Object
- - io.dapr.client.DaprClientHttp

All Implemented Interfaces:
  `DaprClient`, `DaprPreviewClient`, `AutoCloseable`

    @Deprecated
    public class DaprClientHttp
    extends Object

Deprecated.
This class will be deleted at SDK release version 1.10.
An adapter for the HTTP Client.

See Also:
  `DaprHttp`, `DaprClient`

### Field Summary

Fields
`protected static com.fasterxml.jackson.databind.ObjectMapper` `JSON_REQUEST_MAPPER` A mapper to serialize JSON request objects.
`protected DaprObjectSerializer` `objectSerializer` A utility class for serialize and deserialize the transient objects.
`protected DaprObjectSerializer` `stateSerializer` A utility class for serialize and deserialize state objects.

### Method Summary

All Methods Instance Methods Concrete Methods Deprecated Methods
`void` `close()` Deprecated.
`reactor.core.publisher.Mono<Void>` `deleteState​(DeleteStateRequest request)` Deprecated. Delete a state.
`reactor.core.publisher.Mono<Void>` `deleteState​(String storeName, String key)` Delete a state.
`reactor.core.publisher.Mono<Void>` `deleteState​(String storeName, String key, String etag, StateOptions options)` Delete a state.
`reactor.core.publisher.Mono<Void>` `executeStateTransaction​(ExecuteStateTransactionRequest request)` Deprecated. Execute a transaction.
`reactor.core.publisher.Mono<Void>` `executeStateTransaction​(String storeName, List<TransactionalStateOperation<?>> operations)` Execute a transaction.
`reactor.core.publisher.Mono<Map<String,​Map<String,​String>>>` `getBulkSecret​(GetBulkSecretRequest request)` Deprecated. Fetches all secrets from the configured vault.
`reactor.core.publisher.Mono<Map<String,​Map<String,​String>>>` `getBulkSecret​(String storeName)` Fetches all secrets from the configured vault.
`reactor.core.publisher.Mono<Map<String,​Map<String,​String>>>` `getBulkSecret​(String storeName, Map<String,​String> metadata)` Fetches all secrets from the configured vault.
`<T> reactor.core.publisher.Mono<List<State<T>>>` `getBulkState​(GetBulkStateRequest request, TypeRef<T> type)` Deprecated. Retrieve bulk States based on their keys.
`<T> reactor.core.publisher.Mono<List<State<T>>>` `getBulkState​(String storeName, List<String> keys, TypeRef<T> type)` Retrieve bulk States based on their keys.
`<T> reactor.core.publisher.Mono<List<State<T>>>` `getBulkState​(String storeName, List<String> keys, Class<T> clazz)` Retrieve bulk States based on their keys.
`reactor.core.publisher.Mono<Map<String,​ConfigurationItem>>` `getConfiguration​(GetConfigurationRequest request)` Deprecated. Retrieve Map of configurations based on a provided configuration request object.
`reactor.core.publisher.Mono<ConfigurationItem>` `getConfiguration​(String storeName, String key)` Retrieve a configuration based on a provided key.
`reactor.core.publisher.Mono<Map<String,​ConfigurationItem>>` `getConfiguration​(String storeName, String... keys)` Retrieve Map of configurations based on a provided variable number of keys.
`reactor.core.publisher.Mono<ConfigurationItem>` `getConfiguration​(String storeName, String key, Map<String,​String> metadata)` Retrieve a configuration based on a provided key.
`reactor.core.publisher.Mono<Map<String,​ConfigurationItem>>` `getConfiguration​(String storeName, List<String> keys, Map<String,​String> metadata)` Retrieve Map of configurations based on a provided variable number of keys.
`reactor.core.publisher.Mono<Map<String,​String>>` `getSecret​(GetSecretRequest request)` Deprecated. Fetches a secret from the configured vault.
`reactor.core.publisher.Mono<Map<String,​String>>` `getSecret​(String storeName, String secretName)` Fetches a secret from the configured vault.
`reactor.core.publisher.Mono<Map<String,​String>>` `getSecret​(String storeName, String key, Map<String,​String> metadata)` Fetches a secret from the configured vault.
`<T> reactor.core.publisher.Mono<State<T>>` `getState​(GetStateRequest request, TypeRef<T> type)` Deprecated. Retrieve a State based on their key.
`<T> reactor.core.publisher.Mono<State<T>>` `getState​(String storeName, State<T> state, TypeRef<T> type)` Retrieve a State based on their key.
`<T> reactor.core.publisher.Mono<State<T>>` `getState​(String storeName, State<T> state, Class<T> clazz)` Retrieve a State based on their key.
`<T> reactor.core.publisher.Mono<State<T>>` `getState​(String storeName, String key, StateOptions options, TypeRef<T> type)` Retrieve a State based on their key.
`<T> reactor.core.publisher.Mono<State<T>>` `getState​(String storeName, String key, StateOptions options, Class<T> clazz)` Retrieve a State based on their key.
`<T> reactor.core.publisher.Mono<State<T>>` `getState​(String storeName, String key, TypeRef<T> type)` Retrieve a State based on their key.
`<T> reactor.core.publisher.Mono<State<T>>` `getState​(String storeName, String key, Class<T> clazz)` Retrieve a State based on their key.
`<T> reactor.core.publisher.Mono<T>` `invokeBinding​(InvokeBindingRequest request, TypeRef<T> type)` Deprecated. Invokes a Binding operation.
`reactor.core.publisher.Mono<byte[]>` `invokeBinding​(String bindingName, String operation, byte[] data, Map<String,​String> metadata)` Invokes a Binding operation, skipping serialization.
`reactor.core.publisher.Mono<Void>` `invokeBinding​(String bindingName, String operation, Object data)` Invokes a Binding operation.
`<T> reactor.core.publisher.Mono<T>` `invokeBinding​(String bindingName, String operation, Object data, TypeRef<T> type)` Invokes a Binding operation.
`<T> reactor.core.publisher.Mono<T>` `invokeBinding​(String bindingName, String operation, Object data, Class<T> clazz)` Invokes a Binding operation.
`<T> reactor.core.publisher.Mono<T>` `invokeBinding​(String bindingName, String operation, Object data, Map<String,​String> metadata, TypeRef<T> type)` Invokes a Binding operation.
`<T> reactor.core.publisher.Mono<T>` `invokeBinding​(String bindingName, String operation, Object data, Map<String,​String> metadata, Class<T> clazz)` Invokes a Binding operation.
`<T> reactor.core.publisher.Mono<T>` `invokeMethod​(InvokeMethodRequest invokeMethodRequest, TypeRef<T> type)` Deprecated. Invoke a service method.
`reactor.core.publisher.Mono<byte[]>` `invokeMethod​(String appId, String methodName, byte[] request, HttpExtension httpExtension, Map<String,​String> metadata)` Invoke a service method, without using serialization.
`reactor.core.publisher.Mono<Void>` `invokeMethod​(String appId, String methodName, HttpExtension httpExtension, Map<String,​String> metadata)` Invoke a service method, using serialization.
`<T> reactor.core.publisher.Mono<T>` `invokeMethod​(String appId, String methodName, HttpExtension httpExtension, Map<String,​String> metadata, TypeRef<T> type)` Invoke a service method, using serialization.
`<T> reactor.core.publisher.Mono<T>` `invokeMethod​(String appId, String methodName, HttpExtension httpExtension, Map<String,​String> metadata, Class<T> clazz)` Invoke a service method, using serialization.
`reactor.core.publisher.Mono<Void>` `invokeMethod​(String appId, String methodName, Object request, HttpExtension httpExtension)` Invoke a service method, using serialization.
`<T> reactor.core.publisher.Mono<T>` `invokeMethod​(String appId, String methodName, Object request, HttpExtension httpExtension, TypeRef<T> type)` Invoke a service method, using serialization.
`<T> reactor.core.publisher.Mono<T>` `invokeMethod​(String appId, String methodName, Object request, HttpExtension httpExtension, Class<T> clazz)` Invoke a service method, using serialization.
`reactor.core.publisher.Mono<Void>` `invokeMethod​(String appId, String methodName, Object request, HttpExtension httpExtension, Map<String,​String> metadata)` Invoke a service method, using serialization.
`<T> reactor.core.publisher.Mono<T>` `invokeMethod​(String appId, String methodName, Object data, HttpExtension httpExtension, Map<String,​String> metadata, TypeRef<T> type)` Invoke a service method, using serialization.
`<T> reactor.core.publisher.Mono<T>` `invokeMethod​(String appId, String methodName, Object request, HttpExtension httpExtension, Map<String,​String> metadata, Class<T> clazz)` Invoke a service method, using serialization.
`reactor.core.publisher.Mono<Void>` `publishEvent​(PublishEventRequest request)` Deprecated. Publish an event.
`reactor.core.publisher.Mono<Void>` `publishEvent​(String pubsubName, String topicName, Object data)` Publish an event.
`reactor.core.publisher.Mono<Void>` `publishEvent​(String pubsubName, String topicName, Object data, Map<String,​String> metadata)` Publish an event.
`<T> reactor.core.publisher.Mono<BulkPublishResponse<T>>` `publishEvents​(BulkPublishRequest<T> request)` Deprecated. Publish multiple events to Dapr in a single request.
`<T> reactor.core.publisher.Mono<BulkPublishResponse<T>>` `publishEvents​(String pubsubName, String topicName, String contentType, List<T> events)` Publish multiple events to Dapr in a single request.
`<T> reactor.core.publisher.Mono<BulkPublishResponse<T>>` `publishEvents​(String pubsubName, String topicName, String contentType, Map<String,​String> requestMetadata, List<T> events)` Publish multiple events to Dapr in a single request.
`<T> reactor.core.publisher.Mono<BulkPublishResponse<T>>` `publishEvents​(String pubsubName, String topicName, String contentType, Map<String,​String> requestMetadata, T... events)` Publish multiple events to Dapr in a single request.
`<T> reactor.core.publisher.Mono<BulkPublishResponse<T>>` `publishEvents​(String pubsubName, String topicName, String contentType, T... events)` Publish multiple events to Dapr in a single request.
`<T> reactor.core.publisher.Mono<QueryStateResponse<T>>` `queryState​(QueryStateRequest request, TypeRef<T> type)` Deprecated. Query for states using a query request.
`<T> reactor.core.publisher.Mono<QueryStateResponse<T>>` `queryState​(QueryStateRequest request, Class<T> clazz)` Query for states using a query request.
`<T> reactor.core.publisher.Mono<QueryStateResponse<T>>` `queryState​(String storeName, Query query, TypeRef<T> type)` Query for states using a query domain object.
`<T> reactor.core.publisher.Mono<QueryStateResponse<T>>` `queryState​(String storeName, Query query, Class<T> clazz)` Query for states using a query domain object.
`<T> reactor.core.publisher.Mono<QueryStateResponse<T>>` `queryState​(String storeName, Query query, Map<String,​String> metadata, TypeRef<T> type)` Query for states using a query domain object.
`<T> reactor.core.publisher.Mono<QueryStateResponse<T>>` `queryState​(String storeName, Query query, Map<String,​String> metadata, Class<T> clazz)` Query for states using a query domain object.
`<T> reactor.core.publisher.Mono<QueryStateResponse<T>>` `queryState​(String storeName, String query, TypeRef<T> type)` Query for states using a query string.
`<T> reactor.core.publisher.Mono<QueryStateResponse<T>>` `queryState​(String storeName, String query, Class<T> clazz)` Query for states using a query string.
`<T> reactor.core.publisher.Mono<QueryStateResponse<T>>` `queryState​(String storeName, String query, Map<String,​String> metadata, TypeRef<T> type)` Query for states using a query string.
`<T> reactor.core.publisher.Mono<QueryStateResponse<T>>` `queryState​(String storeName, String query, Map<String,​String> metadata, Class<T> clazz)` Query for states using a query string.
`reactor.core.publisher.Mono<Void>` `saveBulkState​(SaveStateRequest request)` Deprecated. Save/Update a list of states.
`reactor.core.publisher.Mono<Void>` `saveBulkState​(String storeName, List<State<?>> states)` Save/Update a list of states.
`reactor.core.publisher.Mono<Void>` `saveState​(String storeName, String key, Object value)` Save/Update a state.
`reactor.core.publisher.Mono<Void>` `saveState​(String storeName, String key, String etag, Object value, StateOptions options)` Save/Update a state.
`reactor.core.publisher.Mono<Void>` `shutdown()` Deprecated. Gracefully shutdown the dapr runtime.
`reactor.core.publisher.Flux<SubscribeConfigurationResponse>` `subscribeConfiguration​(SubscribeConfigurationRequest request)` Deprecated. Subscribe to the keys for any change.
`reactor.core.publisher.Flux<SubscribeConfigurationResponse>` `subscribeConfiguration​(String storeName, String... keys)` Subscribe to the keys for any change.
`reactor.core.publisher.Flux<SubscribeConfigurationResponse>` `subscribeConfiguration​(String storeName, List<String> keys, Map<String,​String> metadata)` Subscribe to the keys for any change.
`reactor.core.publisher.Mono<Boolean>` `tryLock​(LockRequest request)` Deprecated. Tries to get a lock with an expiry.
`reactor.core.publisher.Mono<Boolean>` `tryLock​(String storeName, String resourceId, String lockOwner, Integer expiryInSeconds)` Tries to get a lock with an expiry.
`reactor.core.publisher.Mono<UnlockResponseStatus>` `unlock​(UnlockRequest request)` Deprecated. Unlocks a lock.
`reactor.core.publisher.Mono<UnlockResponseStatus>` `unlock​(String storeName, String resourceId, String lockOwner)` Unlocks a lock.
`reactor.core.publisher.Mono<UnsubscribeConfigurationResponse>` `unsubscribeConfiguration​(UnsubscribeConfigurationRequest request)` Deprecated. Unsubscribe from previously subscribed keys.
`reactor.core.publisher.Mono<UnsubscribeConfigurationResponse>` `unsubscribeConfiguration​(String id, String storeName)` Unsubscribe from previously subscribed keys.
`reactor.core.publisher.Mono<Void>` `waitForSidecar​(int timeoutInMilliseconds)` Deprecated. Waits for the sidecar, giving up after timeout.

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

### Field Detail

#### JSON_REQUEST_MAPPER

    protected static final com.fasterxml.jackson.databind.ObjectMapper JSON_REQUEST_MAPPER

A mapper to serialize JSON request objects.

#### objectSerializer

    protected DaprObjectSerializer objectSerializer

A utility class for serialize and deserialize the transient objects.

#### stateSerializer

    protected DaprObjectSerializer stateSerializer

A utility class for serialize and deserialize state objects.

### Method Detail

#### waitForSidecar

    public reactor.core.publisher.Mono<Void> waitForSidecar​(int timeoutInMilliseconds)

Deprecated.
Waits for the sidecar, giving up after timeout.

Parameters:
  `timeoutInMilliseconds` - Timeout in milliseconds to wait for sidecar.
Returns:
  a Mono plan of type Void.

#### publishEvent

    public reactor.core.publisher.Mono<Void> publishEvent​(PublishEventRequest request)

Deprecated.
Publish an event.

Parameters:
  `request` - the request for the publish event.
Returns:
  a Mono plan of a Dapr's void response.

#### publishEvents

    public <T> reactor.core.publisher.Mono<BulkPublishResponse<T>> publishEvents​(BulkPublishRequest<T> request)

Deprecated.
Publish multiple events to Dapr in a single request.

Type Parameters:
  `T` - The type of events to publish in the call.
Parameters:
  `request` - `BulkPublishRequest` object.
Returns:
  A Mono of `BulkPublishResponse` object.

#### invokeMethod

    public <T> reactor.core.publisher.Mono<T> invokeMethod​(InvokeMethodRequest invokeMethodRequest,
                                                           TypeRef<T> type)

Deprecated.
Invoke a service method.

Type Parameters:
  `T` - The Type of the return, use byte[] to skip serialization.
Parameters:
  `invokeMethodRequest` - Request object.
  `type` - The Type needed as return for the call.
Returns:
  A Mono Plan of type T.

#### invokeBinding

    public <T> reactor.core.publisher.Mono<T> invokeBinding​(InvokeBindingRequest request,
                                                            TypeRef<T> type)

Deprecated.
Invokes a Binding operation.

Type Parameters:
  `T` - The type of the return
Parameters:
  `request` - The binding invocation request.
  `type` - The type being returned.
Returns:
  a Mono plan of type T.

#### getBulkState

    public <T> reactor.core.publisher.Mono<List<State<T>>> getBulkState​(GetBulkStateRequest request,
                                                                        TypeRef<T> type)

Deprecated.
Retrieve bulk States based on their keys.

Type Parameters:
  `T` - The Type of the return.
Parameters:
  `request` - The request to get state.
  `type` - The Type of State needed as return.
Returns:
  A Mono Plan for the requested State.

#### getState

    public <T> reactor.core.publisher.Mono<State<T>> getState​(GetStateRequest request,
                                                              TypeRef<T> type)

Deprecated.
Retrieve a State based on their key.

Type Parameters:
  `T` - The Type of the return.
Parameters:
  `request` - The request to get state.
  `type` - The Type of State needed as return.
Returns:
  A Mono Plan for the requested State.

#### executeStateTransaction

    public reactor.core.publisher.Mono<Void> executeStateTransaction​(ExecuteStateTransactionRequest request)

Deprecated.
Execute a transaction.

Parameters:
  `request` - Request to execute transaction.
Returns:
  a Mono plan of type Response Void

#### saveBulkState

    public reactor.core.publisher.Mono<Void> saveBulkState​(SaveStateRequest request)

Deprecated.
Save/Update a list of states.

Parameters:
  `request` - Request to save states.
Returns:
  a Mono plan of type Void.

#### deleteState

    public reactor.core.publisher.Mono<Void> deleteState​(DeleteStateRequest request)

Deprecated.
Delete a state.

Parameters:
  `request` - Request to delete a state.
Returns:
  a Mono plan of type Void.

#### getSecret

    public reactor.core.publisher.Mono<Map<String,​String>> getSecret​(GetSecretRequest request)

Deprecated.
Fetches a secret from the configured vault.

Parameters:
  `request` - Request to fetch secret.
Returns:
  Key-value pairs for the secret.

#### getBulkSecret

    public reactor.core.publisher.Mono<Map<String,​Map<String,​String>>> getBulkSecret​(GetBulkSecretRequest request)

Deprecated.
Fetches all secrets from the configured vault.

Parameters:
  `request` - Request to fetch secret.
Returns:
  Key-value pairs for the secret.

#### tryLock

    public reactor.core.publisher.Mono<Boolean> tryLock​(LockRequest request)

Deprecated.
Tries to get a lock with an expiry.

Parameters:
  `request` - The request to lock
Returns:
  Whether the lock is successful

#### unlock

    public reactor.core.publisher.Mono<UnlockResponseStatus> unlock​(UnlockRequest request)

Deprecated.
Unlocks a lock.

Parameters:
  `request` - The request to unlock
Returns:
  Unlock result

#### queryState

    public <T> reactor.core.publisher.Mono<QueryStateResponse<T>> queryState​(QueryStateRequest request,
                                                                             TypeRef<T> type)

Deprecated.
Query for states using a query request.

Type Parameters:
  `T` - The Type of the return, use byte[] to skip serialization.
Parameters:
  `request` - Query request object.
  `type` - The type needed as return for the call.
Returns:
  A Mono of QueryStateResponse of type T.

#### close

    public void close()

Deprecated.

#### shutdown

    public reactor.core.publisher.Mono<Void> shutdown()

Deprecated.
Gracefully shutdown the dapr runtime.

Returns:
  a Mono plan of type Void.

#### getConfiguration

    public reactor.core.publisher.Mono<Map<String,​ConfigurationItem>> getConfiguration​(GetConfigurationRequest request)

Deprecated.
Retrieve Map of configurations based on a provided configuration request object.

Parameters:
  `request` - request for retrieving Configurations for a list keys
Returns:
  Mono of Map of ConfigurationItems

#### subscribeConfiguration

    public reactor.core.publisher.Flux<SubscribeConfigurationResponse> subscribeConfiguration​(SubscribeConfigurationRequest request)

Deprecated.
Subscribe to the keys for any change.

Parameters:
  `request` - request for subscribing to any change for the given keys in request
Returns:
  Flux of `SubscribeConfigurationResponse` instance

#### unsubscribeConfiguration

    public reactor.core.publisher.Mono<UnsubscribeConfigurationResponse> unsubscribeConfiguration​(UnsubscribeConfigurationRequest request)

Deprecated.
Unsubscribe from previously subscribed keys.

Parameters:
  `request` - request for unsubscribing to any change for the given subscription id in request
Returns:
  Mono of `UnsubscribeConfigurationResponse` instance.

#### publishEvent

    public reactor.core.publisher.Mono<Void> publishEvent​(String pubsubName,
                                                          String topicName,
                                                          Object data)

Publish an event.

Specified by:
  `publishEvent` in interface `DaprClient`
Parameters:
  `pubsubName` - the pubsub name we will publish the event to
  `topicName` - the topicName where the event will be published.
  `data` - the event's data to be published, use byte[] for skipping serialization.
Returns:
  a Mono plan of type Void.

#### publishEvent

    public reactor.core.publisher.Mono<Void> publishEvent​(String pubsubName,
                                                          String topicName,
                                                          Object data,
                                                          Map<String,​String> metadata)

Publish an event.

Specified by:
  `publishEvent` in interface `DaprClient`
Parameters:
  `pubsubName` - the pubsub name we will publish the event to
  `topicName` - the topicName where the event will be published.
  `data` - the event's data to be published, use byte[] for skipping serialization.
  `metadata` - The metadata for the published event.
Returns:
  a Mono plan of type Void.

#### invokeMethod

    public <T> reactor.core.publisher.Mono<T> invokeMethod​(String appId,
                                                           String methodName,
                                                           Object data,
                                                           HttpExtension httpExtension,
                                                           Map<String,​String> metadata,
                                                           TypeRef<T> type)

Invoke a service method, using serialization.

Specified by:
  `invokeMethod` in interface `DaprClient`
Type Parameters:
  `T` - The Type of the return, use byte[] to skip serialization.
Parameters:
  `appId` - The Application ID where the service is.
  `methodName` - The actual Method to be call in the application.
  `data` - The data to be sent to invoke the service, use byte[] to skip serialization.
  `httpExtension` - Additional fields that are needed if the receiving app is listening on HTTP, `HttpExtension.NONE` otherwise.
  `metadata` - Metadata (in GRPC) or headers (in HTTP) to be sent in data.
  `type` - The Type needed as return for the call.
Returns:
  A Mono Plan of type T.

#### invokeMethod

    public <T> reactor.core.publisher.Mono<T> invokeMethod​(String appId,
                                                           String methodName,
                                                           Object request,
                                                           HttpExtension httpExtension,
                                                           Map<String,​String> metadata,
                                                           Class<T> clazz)

Invoke a service method, using serialization.

Specified by:
  `invokeMethod` in interface `DaprClient`
Type Parameters:
  `T` - The Type of the return, use byte[] to skip serialization.
Parameters:
  `appId` - The Application ID where the service is.
  `methodName` - The actual Method to be call in the application.
  `request` - The request to be sent to invoke the service, use byte[] to skip serialization.
  `httpExtension` - Additional fields that are needed if the receiving app is listening on HTTP, `HttpExtension.NONE` otherwise.
  `metadata` - Metadata (in GRPC) or headers (in HTTP) to be sent in request.
  `clazz` - The type needed as return for the call.
Returns:
  A Mono Plan of type T.

#### invokeMethod

    public <T> reactor.core.publisher.Mono<T> invokeMethod​(String appId,
                                                           String methodName,
                                                           HttpExtension httpExtension,
                                                           Map<String,​String> metadata,
                                                           TypeRef<T> type)

Invoke a service method, using serialization.

Specified by:
  `invokeMethod` in interface `DaprClient`
Type Parameters:
  `T` - The Type of the return, use byte[] to skip serialization.
Parameters:
  `appId` - The Application ID where the service is.
  `methodName` - The actual Method to be call in the application.
  `httpExtension` - Additional fields that are needed if the receiving app is listening on HTTP, `HttpExtension.NONE` otherwise.
  `metadata` - Metadata (in GRPC) or headers (in HTTP) to be sent in request.
  `type` - The Type needed as return for the call.
Returns:
  A Mono Plan of type T.

#### invokeMethod

    public <T> reactor.core.publisher.Mono<T> invokeMethod​(String appId,
                                                           String methodName,
                                                           HttpExtension httpExtension,
                                                           Map<String,​String> metadata,
                                                           Class<T> clazz)

Invoke a service method, using serialization.

Specified by:
  `invokeMethod` in interface `DaprClient`
Type Parameters:
  `T` - The Type of the return, use byte[] to skip serialization.
Parameters:
  `appId` - The Application ID where the service is.
  `methodName` - The actual Method to be call in the application.
  `httpExtension` - Additional fields that are needed if the receiving app is listening on HTTP, `HttpExtension.NONE` otherwise.
  `metadata` - Metadata (in GRPC) or headers (in HTTP) to be sent in request.
  `clazz` - The type needed as return for the call.
Returns:
  A Mono Plan of type T.

#### invokeMethod

    public <T> reactor.core.publisher.Mono<T> invokeMethod​(String appId,
                                                           String methodName,
                                                           Object request,
                                                           HttpExtension httpExtension,
                                                           TypeRef<T> type)

Invoke a service method, using serialization.

Specified by:
  `invokeMethod` in interface `DaprClient`
Type Parameters:
  `T` - The Type of the return, use byte[] to skip serialization.
Parameters:
  `appId` - The Application ID where the service is.
  `methodName` - The actual Method to be call in the application.
  `request` - The request to be sent to invoke the service, use byte[] to skip serialization.
  `httpExtension` - Additional fields that are needed if the receiving app is listening on HTTP, `HttpExtension.NONE` otherwise.
  `type` - The Type needed as return for the call.
Returns:
  A Mono Plan of type T.

#### invokeMethod

    public <T> reactor.core.publisher.Mono<T> invokeMethod​(String appId,
                                                           String methodName,
                                                           Object request,
                                                           HttpExtension httpExtension,
                                                           Class<T> clazz)

Invoke a service method, using serialization.

Specified by:
  `invokeMethod` in interface `DaprClient`
Type Parameters:
  `T` - The Type of the return, use byte[] to skip serialization.
Parameters:
  `appId` - The Application ID where the service is.
  `methodName` - The actual Method to be call in the application.
  `request` - The request to be sent to invoke the service, use byte[] to skip serialization.
  `httpExtension` - Additional fields that are needed if the receiving app is listening on HTTP, `HttpExtension.NONE` otherwise.
  `clazz` - The type needed as return for the call.
Returns:
  A Mono Plan of type T.

#### invokeMethod

    public reactor.core.publisher.Mono<Void> invokeMethod​(String appId,
                                                          String methodName,
                                                          Object request,
                                                          HttpExtension httpExtension)

Invoke a service method, using serialization.

Specified by:
  `invokeMethod` in interface `DaprClient`
Parameters:
  `appId` - The Application ID where the service is.
  `methodName` - The actual Method to be call in the application.
  `request` - The request to be sent to invoke the service, use byte[] to skip serialization.
  `httpExtension` - Additional fields that are needed if the receiving app is listening on HTTP, `HttpExtension.NONE` otherwise.
Returns:
  A Mono Plan of type Void.

#### invokeMethod

    public reactor.core.publisher.Mono<Void> invokeMethod​(String appId,
                                                          String methodName,
                                                          Object request,
                                                          HttpExtension httpExtension,
                                                          Map<String,​String> metadata)

Invoke a service method, using serialization.

Specified by:
  `invokeMethod` in interface `DaprClient`
Parameters:
  `appId` - The Application ID where the service is.
  `methodName` - The actual Method to be call in the application.
  `request` - The request to be sent to invoke the service, use byte[] to skip serialization.
  `httpExtension` - Additional fields that are needed if the receiving app is listening on HTTP, `HttpExtension.NONE` otherwise.
  `metadata` - Metadata (in GRPC) or headers (in HTTP) to be sent in request.
Returns:
  A Mono Plan of type Void.

#### invokeMethod

    public reactor.core.publisher.Mono<Void> invokeMethod​(String appId,
                                                          String methodName,
                                                          HttpExtension httpExtension,
                                                          Map<String,​String> metadata)

Invoke a service method, using serialization.

Specified by:
  `invokeMethod` in interface `DaprClient`
Parameters:
  `appId` - The Application ID where the service is.
  `methodName` - The actual Method to be call in the application.
  `httpExtension` - Additional fields that are needed if the receiving app is listening on HTTP, `HttpExtension.NONE` otherwise.
  `metadata` - Metadata (in GRPC) or headers (in HTTP) to be sent in request.
Returns:
  A Mono Plan of type Void.

#### invokeMethod

    public reactor.core.publisher.Mono<byte[]> invokeMethod​(String appId,
                                                            String methodName,
                                                            byte[] request,
                                                            HttpExtension httpExtension,
                                                            Map<String,​String> metadata)

Invoke a service method, without using serialization.

Specified by:
  `invokeMethod` in interface `DaprClient`
Parameters:
  `appId` - The Application ID where the service is.
  `methodName` - The actual Method to be call in the application.
  `request` - The request to be sent to invoke the service, use byte[] to skip serialization.
  `httpExtension` - Additional fields that are needed if the receiving app is listening on HTTP, `HttpExtension.NONE` otherwise.
  `metadata` - Metadata (in GRPC) or headers (in HTTP) to be sent in request.
Returns:
  A Mono Plan of type byte[].

#### invokeBinding

    public reactor.core.publisher.Mono<Void> invokeBinding​(String bindingName,
                                                           String operation,
                                                           Object data)

Invokes a Binding operation.

Specified by:
  `invokeBinding` in interface `DaprClient`
Parameters:
  `bindingName` - The bindingName of the biding to call.
  `operation` - The operation to be performed by the binding request processor.
  `data` - The data to be processed, use byte[] to skip serialization.
Returns:
  an empty Mono.

#### invokeBinding

    public reactor.core.publisher.Mono<byte[]> invokeBinding​(String bindingName,
                                                             String operation,
                                                             byte[] data,
                                                             Map<String,​String> metadata)

Invokes a Binding operation, skipping serialization.

Specified by:
  `invokeBinding` in interface `DaprClient`
Parameters:
  `bindingName` - The name of the biding to call.
  `operation` - The operation to be performed by the binding request processor.
  `data` - The data to be processed, skipping serialization.
  `metadata` - The metadata map.
Returns:
  a Mono plan of type byte[].

#### invokeBinding

    public <T> reactor.core.publisher.Mono<T> invokeBinding​(String bindingName,
                                                            String operation,
                                                            Object data,
                                                            TypeRef<T> type)

Invokes a Binding operation.

Specified by:
  `invokeBinding` in interface `DaprClient`
Type Parameters:
  `T` - The type of the return
Parameters:
  `bindingName` - The name of the biding to call.
  `operation` - The operation to be performed by the binding request processor.
  `data` - The data to be processed, use byte[] to skip serialization.
  `type` - The type being returned.
Returns:
  a Mono plan of type T.

#### invokeBinding

    public <T> reactor.core.publisher.Mono<T> invokeBinding​(String bindingName,
                                                            String operation,
                                                            Object data,
                                                            Class<T> clazz)

Invokes a Binding operation.

Specified by:
  `invokeBinding` in interface `DaprClient`
Type Parameters:
  `T` - The type of the return
Parameters:
  `bindingName` - The name of the biding to call.
  `operation` - The operation to be performed by the binding request processor.
  `data` - The data to be processed, use byte[] to skip serialization.
  `clazz` - The type being returned.
Returns:
  a Mono plan of type T.

#### invokeBinding

    public <T> reactor.core.publisher.Mono<T> invokeBinding​(String bindingName,
                                                            String operation,
                                                            Object data,
                                                            Map<String,​String> metadata,
                                                            TypeRef<T> type)

Invokes a Binding operation.

Specified by:
  `invokeBinding` in interface `DaprClient`
Type Parameters:
  `T` - The type of the return
Parameters:
  `bindingName` - The name of the biding to call.
  `operation` - The operation to be performed by the binding request processor.
  `data` - The data to be processed, use byte[] to skip serialization.
  `metadata` - The metadata map.
  `type` - The type being returned.
Returns:
  a Mono plan of type T.

#### invokeBinding

    public <T> reactor.core.publisher.Mono<T> invokeBinding​(String bindingName,
                                                            String operation,
                                                            Object data,
                                                            Map<String,​String> metadata,
                                                            Class<T> clazz)

Invokes a Binding operation.

Specified by:
  `invokeBinding` in interface `DaprClient`
Type Parameters:
  `T` - The type of the return
Parameters:
  `bindingName` - The name of the biding to call.
  `operation` - The operation to be performed by the binding request processor.
  `data` - The data to be processed, use byte[] to skip serialization.
  `metadata` - The metadata map.
  `clazz` - The type being returned.
Returns:
  a Mono plan of type T.

#### getState

    public <T> reactor.core.publisher.Mono<State<T>> getState​(String storeName,
                                                              State<T> state,
                                                              TypeRef<T> type)

Retrieve a State based on their key.

Specified by:
  `getState` in interface `DaprClient`
Type Parameters:
  `T` - The type of the return.
Parameters:
  `storeName` - The name of the state store.
  `state` - State to be re-retrieved.
  `type` - The type of State needed as return.
Returns:
  A Mono Plan for the requested State.

#### getState

    public <T> reactor.core.publisher.Mono<State<T>> getState​(String storeName,
                                                              State<T> state,
                                                              Class<T> clazz)

Retrieve a State based on their key.

Specified by:
  `getState` in interface `DaprClient`
Type Parameters:
  `T` - The type of the return.
Parameters:
  `storeName` - The name of the state store.
  `state` - State to be re-retrieved.
  `clazz` - The type of State needed as return.
Returns:
  A Mono Plan for the requested State.

#### getState

    public <T> reactor.core.publisher.Mono<State<T>> getState​(String storeName,
                                                              String key,
                                                              TypeRef<T> type)

Retrieve a State based on their key.

Specified by:
  `getState` in interface `DaprClient`
Type Parameters:
  `T` - The type of the return.
Parameters:
  `storeName` - The name of the state store.
  `key` - The key of the State to be retrieved.
  `type` - The type of State needed as return.
Returns:
  A Mono Plan for the requested State.

#### getState

    public <T> reactor.core.publisher.Mono<State<T>> getState​(String storeName,
                                                              String key,
                                                              Class<T> clazz)

Retrieve a State based on their key.

Specified by:
  `getState` in interface `DaprClient`
Type Parameters:
  `T` - The type of the return.
Parameters:
  `storeName` - The name of the state store.
  `key` - The key of the State to be retrieved.
  `clazz` - The type of State needed as return.
Returns:
  A Mono Plan for the requested State.

#### getState

    public <T> reactor.core.publisher.Mono<State<T>> getState​(String storeName,
                                                              String key,
                                                              StateOptions options,
                                                              TypeRef<T> type)

Retrieve a State based on their key.

Specified by:
  `getState` in interface `DaprClient`
Type Parameters:
  `T` - The Type of the return.
Parameters:
  `storeName` - The name of the state store.
  `key` - The key of the State to be retrieved.
  `options` - Optional settings for retrieve operation.
  `type` - The Type of State needed as return.
Returns:
  A Mono Plan for the requested State.

#### getState

    public <T> reactor.core.publisher.Mono<State<T>> getState​(String storeName,
                                                              String key,
                                                              StateOptions options,
                                                              Class<T> clazz)

Retrieve a State based on their key.

Specified by:
  `getState` in interface `DaprClient`
Type Parameters:
  `T` - The Type of the return.
Parameters:
  `storeName` - The name of the state store.
  `key` - The key of the State to be retrieved.
  `options` - Optional settings for retrieve operation.
  `clazz` - The Type of State needed as return.
Returns:
  A Mono Plan for the requested State.

#### queryState

    public <T> reactor.core.publisher.Mono<QueryStateResponse<T>> queryState​(String storeName,
                                                                             String query,
                                                                             Map<String,​String> metadata,
                                                                             Class<T> clazz)

Query for states using a query string.

Specified by:
  `queryState` in interface `DaprPreviewClient`
Type Parameters:
  `T` - The Type of the return, use byte[] to skip serialization.
Parameters:
  `storeName` - Name of the state store to query.
  `query` - String value of the query.
  `metadata` - Optional metadata passed to the state store.
  `clazz` - The type needed as return for the call.
Returns:
  A Mono of QueryStateResponse of type T.

#### queryState

    public <T> reactor.core.publisher.Mono<QueryStateResponse<T>> queryState​(String storeName,
                                                                             String query,
                                                                             Map<String,​String> metadata,
                                                                             TypeRef<T> type)

Query for states using a query string.

Specified by:
  `queryState` in interface `DaprPreviewClient`
Type Parameters:
  `T` - The Type of the return, use byte[] to skip serialization.
Parameters:
  `storeName` - Name of the state store to query.
  `query` - String value of the query.
  `metadata` - Optional metadata passed to the state store.
  `type` - The type needed as return for the call.
Returns:
  A Mono of QueryStateResponse of type T.

#### queryState

    public <T> reactor.core.publisher.Mono<QueryStateResponse<T>> queryState​(String storeName,
                                                                             String query,
                                                                             Class<T> clazz)

Query for states using a query string.

Specified by:
  `queryState` in interface `DaprPreviewClient`
Type Parameters:
  `T` - The Type of the return, use byte[] to skip serialization.
Parameters:
  `storeName` - Name of the state store to query.
  `query` - String value of the query.
  `clazz` - The type needed as return for the call.
Returns:
  A Mono of QueryStateResponse of type T.

#### queryState

    public <T> reactor.core.publisher.Mono<QueryStateResponse<T>> queryState​(String storeName,
                                                                             String query,
                                                                             TypeRef<T> type)

Query for states using a query string.

Specified by:
  `queryState` in interface `DaprPreviewClient`
Type Parameters:
  `T` - The Type of the return, use byte[] to skip serialization.
Parameters:
  `storeName` - Name of the state store to query.
  `query` - String value of the query.
  `type` - The type needed as return for the call.
Returns:
  A Mono of QueryStateResponse of type T.

#### queryState

    public <T> reactor.core.publisher.Mono<QueryStateResponse<T>> queryState​(String storeName,
                                                                             Query query,
                                                                             Map<String,​String> metadata,
                                                                             Class<T> clazz)

Query for states using a query domain object.

Specified by:
  `queryState` in interface `DaprPreviewClient`
Type Parameters:
  `T` - The Type of the return, use byte[] to skip serialization.
Parameters:
  `storeName` - Name of the state store to query.
  `query` - Query value domain object.
  `metadata` - Optional metadata passed to the state store.
  `clazz` - The type needed as return for the call.
Returns:
  A Mono of QueryStateResponse of type T.

#### queryState

    public <T> reactor.core.publisher.Mono<QueryStateResponse<T>> queryState​(String storeName,
                                                                             Query query,
                                                                             Map<String,​String> metadata,
                                                                             TypeRef<T> type)

Query for states using a query domain object.

Specified by:
  `queryState` in interface `DaprPreviewClient`
Type Parameters:
  `T` - The Type of the return, use byte[] to skip serialization.
Parameters:
  `storeName` - Name of the state store to query.
  `query` - Query value domain object.
  `metadata` - Optional metadata passed to the state store.
  `type` - The type needed as return for the call.
Returns:
  A Mono of QueryStateResponse of type T.

#### queryState

    public <T> reactor.core.publisher.Mono<QueryStateResponse<T>> queryState​(String storeName,
                                                                             Query query,
                                                                             Class<T> clazz)

Query for states using a query domain object.

Specified by:
  `queryState` in interface `DaprPreviewClient`
Type Parameters:
  `T` - The Type of the return, use byte[] to skip serialization.
Parameters:
  `storeName` - Name of the state store to query.
  `query` - Query value domain object.
  `clazz` - The type needed as return for the call.
Returns:
  A Mono of QueryStateResponse of type T.

#### queryState

    public <T> reactor.core.publisher.Mono<QueryStateResponse<T>> queryState​(String storeName,
                                                                             Query query,
                                                                             TypeRef<T> type)

Query for states using a query domain object.

Specified by:
  `queryState` in interface `DaprPreviewClient`
Type Parameters:
  `T` - The Type of the return, use byte[] to skip serialization.
Parameters:
  `storeName` - Name of the state store to query.
  `query` - Query value domain object.
  `type` - The type needed as return for the call.
Returns:
  A Mono of QueryStateResponse of type T.

#### queryState

    public <T> reactor.core.publisher.Mono<QueryStateResponse<T>> queryState​(QueryStateRequest request,
                                                                             Class<T> clazz)

Query for states using a query request.

Specified by:
  `queryState` in interface `DaprPreviewClient`
Type Parameters:
  `T` - The Type of the return, use byte[] to skip serialization.
Parameters:
  `request` - Query request object.
  `clazz` - The type needed as return for the call.
Returns:
  A Mono of QueryStateResponse of type T.

#### publishEvents

    public <T> reactor.core.publisher.Mono<BulkPublishResponse<T>> publishEvents​(String pubsubName,
                                                                                 String topicName,
                                                                                 String contentType,
                                                                                 List<T> events)

Publish multiple events to Dapr in a single request.

Specified by:
  `publishEvents` in interface `DaprPreviewClient`
Type Parameters:
  `T` - The type of the events to publish in the call.
Parameters:
  `pubsubName` - the pubsub name we will publish the event to.
  `topicName` - the topicName where the event will be published.
  `contentType` - the content type of the event. Use Mime based types.
  `events` - the `List` of events to be published.
Returns:
  the `BulkPublishResponse` containing publish status of each event. The "entryID" field in `BulkPublishEntry` in `BulkPublishResponseFailedEntry` will be generated based on the order of events in the `List`.

#### publishEvents

    public <T> reactor.core.publisher.Mono<BulkPublishResponse<T>> publishEvents​(String pubsubName,
                                                                                 String topicName,
                                                                                 String contentType,
                                                                                 T... events)

Publish multiple events to Dapr in a single request.

Specified by:
  `publishEvents` in interface `DaprPreviewClient`
Type Parameters:
  `T` - The type of the events to publish in the call.
Parameters:
  `pubsubName` - the pubsub name we will publish the event to.
  `topicName` - the topicName where the event will be published.
  `contentType` - the content type of the event. Use Mime based types.
  `events` - the varargs of events to be published.
Returns:
  the `BulkPublishResponse` containing publish status of each event. The "entryID" field in `BulkPublishEntry` in `BulkPublishResponseFailedEntry` will be generated based on the order of events in the `List`.

#### publishEvents

    public <T> reactor.core.publisher.Mono<BulkPublishResponse<T>> publishEvents​(String pubsubName,
                                                                                 String topicName,
                                                                                 String contentType,
                                                                                 Map<String,​String> requestMetadata,
                                                                                 T... events)

Publish multiple events to Dapr in a single request.

Specified by:
  `publishEvents` in interface `DaprPreviewClient`
Type Parameters:
  `T` - The type of the events to publish in the call.
Parameters:
  `pubsubName` - the pubsub name we will publish the event to.
  `topicName` - the topicName where the event will be published.
  `contentType` - the content type of the event. Use Mime based types.
  `requestMetadata` - the metadata to be set at the request level for the `BulkPublishRequest`.
  `events` - the varargs of events to be published.
Returns:
  the `BulkPublishResponse` containing publish status of each event. The "entryID" field in `BulkPublishEntry` in `BulkPublishResponseFailedEntry` will be generated based on the order of events in the `List`.

#### publishEvents

    public <T> reactor.core.publisher.Mono<BulkPublishResponse<T>> publishEvents​(String pubsubName,
                                                                                 String topicName,
                                                                                 String contentType,
                                                                                 Map<String,​String> requestMetadata,
                                                                                 List<T> events)

Publish multiple events to Dapr in a single request.

Specified by:
  `publishEvents` in interface `DaprPreviewClient`
Type Parameters:
  `T` - The type of the events to publish in the call.
Parameters:
  `pubsubName` - the pubsub name we will publish the event to.
  `topicName` - the topicName where the event will be published.
  `contentType` - the content type of the event. Use Mime based types.
  `requestMetadata` - the metadata to be set at the request level for the `BulkPublishRequest`.
  `events` - the `List` of events to be published.
Returns:
  the `BulkPublishResponse` containing publish status of each event. The "entryID" field in `BulkPublishEntry` in `BulkPublishResponseFailedEntry` will be generated based on the order of events in the `List`.

#### getBulkState

    public <T> reactor.core.publisher.Mono<List<State<T>>> getBulkState​(String storeName,
                                                                        List<String> keys,
                                                                        TypeRef<T> type)

Retrieve bulk States based on their keys.

Specified by:
  `getBulkState` in interface `DaprClient`
Type Parameters:
  `T` - The type of the return.
Parameters:
  `storeName` - The name of the state store.
  `keys` - The keys of the State to be retrieved.
  `type` - The type of State needed as return.
Returns:
  A Mono Plan for the requested State.

#### getBulkState

    public <T> reactor.core.publisher.Mono<List<State<T>>> getBulkState​(String storeName,
                                                                        List<String> keys,
                                                                        Class<T> clazz)

Retrieve bulk States based on their keys.

Specified by:
  `getBulkState` in interface `DaprClient`
Type Parameters:
  `T` - The type of the return.
Parameters:
  `storeName` - The name of the state store.
  `keys` - The keys of the State to be retrieved.
  `clazz` - The type of State needed as return.
Returns:
  A Mono Plan for the requested State.

#### executeStateTransaction

    public reactor.core.publisher.Mono<Void> executeStateTransaction​(String storeName,
                                                                     List<TransactionalStateOperation<?>> operations)

Execute a transaction.

Specified by:
  `executeStateTransaction` in interface `DaprClient`
Parameters:
  `storeName` - The name of the state store.
  `operations` - The operations to be performed.
Returns:
  a Mono plan of type Void

#### saveBulkState

    public reactor.core.publisher.Mono<Void> saveBulkState​(String storeName,
                                                           List<State<?>> states)

Save/Update a list of states.

Specified by:
  `saveBulkState` in interface `DaprClient`
Parameters:
  `storeName` - The name of the state store.
  `states` - The States to be saved.
Returns:
  a Mono plan of type Void.

#### saveState

    public reactor.core.publisher.Mono<Void> saveState​(String storeName,
                                                       String key,
                                                       Object value)

Save/Update a state.

Specified by:
  `saveState` in interface `DaprClient`
Parameters:
  `storeName` - The name of the state store.
  `key` - The key of the state.
  `value` - The value of the state.
Returns:
  a Mono plan of type Void.

#### saveState

    public reactor.core.publisher.Mono<Void> saveState​(String storeName,
                                                       String key,
                                                       String etag,
                                                       Object value,
                                                       StateOptions options)

Save/Update a state.

Specified by:
  `saveState` in interface `DaprClient`
Parameters:
  `storeName` - The name of the state store.
  `key` - The key of the state.
  `etag` - The etag to be used.
  `value` - The value of the state.
  `options` - The Options to use for each state.
Returns:
  a Mono plan of type Void.

#### deleteState

    public reactor.core.publisher.Mono<Void> deleteState​(String storeName,
                                                         String key)

Delete a state.

Specified by:
  `deleteState` in interface `DaprClient`
Parameters:
  `storeName` - The name of the state store.
  `key` - The key of the State to be removed.
Returns:
  a Mono plan of type Void.

#### deleteState

    public reactor.core.publisher.Mono<Void> deleteState​(String storeName,
                                                         String key,
                                                         String etag,
                                                         StateOptions options)

Delete a state.

Specified by:
  `deleteState` in interface `DaprClient`
Parameters:
  `storeName` - The name of the state store.
  `key` - The key of the State to be removed.
  `etag` - Optional etag for conditional delete.
  `options` - Optional settings for state operation.
Returns:
  a Mono plan of type Void.

#### getSecret

    public reactor.core.publisher.Mono<Map<String,​String>> getSecret​(String storeName,
                                                                           String key,
                                                                           Map<String,​String> metadata)

Fetches a secret from the configured vault.

Specified by:
  `getSecret` in interface `DaprClient`
Parameters:
  `storeName` - Name of vault component in Dapr.
  `key` - Secret to be fetched.
  `metadata` - Optional metadata.
Returns:
  Key-value pairs for the secret.

#### getSecret

    public reactor.core.publisher.Mono<Map<String,​String>> getSecret​(String storeName,
                                                                           String secretName)

Fetches a secret from the configured vault.

Specified by:
  `getSecret` in interface `DaprClient`
Parameters:
  `storeName` - Name of vault component in Dapr.
  `secretName` - Secret to be fetched.
Returns:
  Key-value pairs for the secret.

#### getBulkSecret

    public reactor.core.publisher.Mono<Map<String,​Map<String,​String>>> getBulkSecret​(String storeName)

Fetches all secrets from the configured vault.

Specified by:
  `getBulkSecret` in interface `DaprClient`
Parameters:
  `storeName` - Name of vault component in Dapr.
Returns:
  Key-value pairs for all the secrets in the state store.

#### getBulkSecret

    public reactor.core.publisher.Mono<Map<String,​Map<String,​String>>> getBulkSecret​(String storeName,
                                                                                                 Map<String,​String> metadata)

Fetches all secrets from the configured vault.

Specified by:
  `getBulkSecret` in interface `DaprClient`
Parameters:
  `storeName` - Name of vault component in Dapr.
  `metadata` - Optional metadata.
Returns:
  Key-value pairs for all the secrets in the state store.

#### getConfiguration

    public reactor.core.publisher.Mono<ConfigurationItem> getConfiguration​(String storeName,
                                                                           String key)

Retrieve a configuration based on a provided key.

Specified by:
  `getConfiguration` in interface `DaprClient`
Parameters:
  `storeName` - Name of the configuration store
  `key` - key of the configuration item which is to be retrieved
Returns:
  Mono of the Configuration Item

#### getConfiguration

    public reactor.core.publisher.Mono<ConfigurationItem> getConfiguration​(String storeName,
                                                                           String key,
                                                                           Map<String,​String> metadata)

Retrieve a configuration based on a provided key.

Specified by:
  `getConfiguration` in interface `DaprClient`
Parameters:
  `storeName` - Name of the configuration store
  `key` - key of the configuration item which is to be retrieved
  `metadata` - optional metadata
Returns:
  Mono of the Configuration Item

#### getConfiguration

    public reactor.core.publisher.Mono<Map<String,​ConfigurationItem>> getConfiguration​(String storeName,
                                                                                             String... keys)

Retrieve Map of configurations based on a provided variable number of keys.

Specified by:
  `getConfiguration` in interface `DaprClient`
Parameters:
  `storeName` - Name of the configuration store
  `keys` - keys of the configurations which are to be retrieved
Returns:
  Mono of Map of ConfigurationItems

#### getConfiguration

    public reactor.core.publisher.Mono<Map<String,​ConfigurationItem>> getConfiguration​(String storeName,
                                                                                             List<String> keys,
                                                                                             Map<String,​String> metadata)

Retrieve Map of configurations based on a provided variable number of keys.

Specified by:
  `getConfiguration` in interface `DaprClient`
Parameters:
  `storeName` - Name of the configuration store
  `keys` - keys of the configurations which are to be retrieved
  `metadata` - optional metadata
Returns:
  Mono of Map of ConfigurationItems

#### subscribeConfiguration

    public reactor.core.publisher.Flux<SubscribeConfigurationResponse> subscribeConfiguration​(String storeName,
                                                                                              String... keys)

Subscribe to the keys for any change.

Specified by:
  `subscribeConfiguration` in interface `DaprClient`
Parameters:
  `storeName` - Name of the configuration store
  `keys` - keys of the configurations which are to be subscribed
Returns:
  Flux of `SubscribeConfigurationResponse` instance

#### subscribeConfiguration

    public reactor.core.publisher.Flux<SubscribeConfigurationResponse> subscribeConfiguration​(String storeName,
                                                                                              List<String> keys,
                                                                                              Map<String,​String> metadata)

Subscribe to the keys for any change.

Specified by:
  `subscribeConfiguration` in interface `DaprClient`
Parameters:
  `storeName` - Name of the configuration store
  `keys` - keys of the configurations which are to be subscribed
  `metadata` - optional metadata
Returns:
  Flux of `SubscribeConfigurationResponse` instance

#### unsubscribeConfiguration

    public reactor.core.publisher.Mono<UnsubscribeConfigurationResponse> unsubscribeConfiguration​(String id,
                                                                                                  String storeName)

Unsubscribe from previously subscribed keys.

Specified by:
  `unsubscribeConfiguration` in interface `DaprClient`
Parameters:
  `id` - subscription id returned by subscribeConfiguration API.
  `storeName` - Name of the configuration store.
Returns:
  Mono of `UnsubscribeConfigurationResponse` instance.

#### tryLock

    public reactor.core.publisher.Mono<Boolean> tryLock​(String storeName,
                                                        String resourceId,
                                                        String lockOwner,
                                                        Integer expiryInSeconds)

Tries to get a lock with an expiry.

Specified by:
  `tryLock` in interface `DaprPreviewClient`
Parameters:
  `storeName` - Name of the store
  `resourceId` - Lock key
  `lockOwner` - The identifier of lock owner
  `expiryInSeconds` - The time before expiry
Returns:
  Whether the lock is successful

#### unlock

    public reactor.core.publisher.Mono<UnlockResponseStatus> unlock​(String storeName,
                                                                    String resourceId,
                                                                    String lockOwner)

Unlocks a lock.

Specified by:
  `unlock` in interface `DaprPreviewClient`
Parameters:
  `storeName` - Name of the store
  `resourceId` - Lock key
  `lockOwner` - The identifier of lock owner
Returns:
  Unlock result