class CoherenceProxyManager<K> extends AbstractProxyManager<K> {

    private final NamedCache<K, byte[]> cache;

    public CoherenceProxyManager(NamedCache<K, byte[]> cache) {
        this(cache, ClientSideConfig.getDefault());
    }

    public CoherenceProxyManager(NamedCache<K, byte[]> cache, ClientSideConfig clientSideConfig) {
        super(clientSideConfig);
        this.cache = cache;
    }

    @Override
    public <T> CommandResult<T> execute(K key, Request<T> request) {
        CoherenceProcessor<K, T> entryProcessor = new CoherenceProcessor<>(request);
        byte[] resultBytes = cache.invoke(key, entryProcessor);
        Version backwardCompatibilityVersion = request.getBackwardCompatibilityVersion();
        return deserializeResult(resultBytes, backwardCompatibilityVersion);
    }

    @Override
    public void removeProxy(K key) {
        cache.remove(key);
    }

    @Override
    public boolean isAsyncModeSupported() {
        return true;
    }

    @Override
    public <T> CompletableFuture<CommandResult<T>> executeAsync(K key, Request<T> request) {<FILL_FUNCTION_BODY>}

    @Override
    protected CompletableFuture<Void> removeAsync(K key) {
        return cache.async().remove(key).thenApply(oldState -> null);
    }

}

        CoherenceProcessor<K, T> entryProcessor = new CoherenceProcessor<>(request);
        CompletableFuture<CommandResult<T>> future = new CompletableFuture<>();
        Version backwardCompatibilityVersion = request.getBackwardCompatibilityVersion();
        SingleEntryAsynchronousProcessor<K, byte[], byte[]> asyncProcessor =
            new SingleEntryAsynchronousProcessor<K, byte[], byte[]>(entryProcessor) {
                @Override
                public void onResult(Map.Entry<K, byte[]> entry) {
                    super.onResult(entry);
                    byte[] resultBytes = entry.getValue();
                    future.complete(deserializeResult(resultBytes, backwardCompatibilityVersion));
                }
                @Override
                public void onException(Throwable error) {
                    super.onException(error);
                    future.completeExceptionally(error);
                }
            };
        cache.invoke(key, asyncProcessor);
        return future;
    
<methods>public AsyncProxyManager<K> asAsync() ,public RemoteBucketBuilder<K> builder() ,public Optional<io.github.bucket4j.BucketConfiguration> getProxyConfiguration(K) <variables>private static final io.github.bucket4j.distributed.proxy.RecoveryStrategy DEFAULT_RECOVERY_STRATEGY,private static final io.github.bucket4j.distributed.proxy.optimization.Optimization DEFAULT_REQUEST_OPTIMIZER,private AsyncProxyManager<K> asyncView,private final non-sealed io.github.bucket4j.distributed.proxy.ClientSideConfig clientSideConfig