• Home
• io.reactiverse
• elasticsearch-client-rxjava2
• 0.9.0-ec7.10.1
• source code
• IndicesClient.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

io.reactiverse.elasticsearch.client.reactivex.IndicesClient Maven / Gradle / Ivy

/*
 * Copyright 2014 Red Hat, Inc.
 *
 * Red Hat licenses this file to you under the Apache License, version 2.0
 * (the "License"); you may not use this file except in compliance with the
 * License.  You may obtain a copy of the License at:
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
 * License for the specific language governing permissions and limitations
 * under the License.
 */

package io.reactiverse.elasticsearch.client.reactivex;

import io.vertx.reactivex.RxHelper;
import io.vertx.reactivex.ObservableHelper;
import io.vertx.reactivex.FlowableHelper;
import io.vertx.reactivex.impl.AsyncResultMaybe;
import io.vertx.reactivex.impl.AsyncResultSingle;
import io.vertx.reactivex.impl.AsyncResultCompletable;
import io.vertx.reactivex.WriteStreamObserver;
import io.vertx.reactivex.WriteStreamSubscriber;
import java.util.Map;
import java.util.Set;
import java.util.List;
import java.util.Iterator;
import java.util.function.Function;
import java.util.stream.Collectors;
import io.vertx.core.Handler;
import io.vertx.core.AsyncResult;
import io.vertx.core.json.JsonObject;
import io.vertx.core.json.JsonArray;
import io.vertx.lang.rx.RxGen;
import io.vertx.lang.rx.TypeArg;
import io.vertx.lang.rx.MappingIterator;


@RxGen(io.reactiverse.elasticsearch.client.IndicesClient.class)
public class IndicesClient {

  @Override
  public String toString() {
    return delegate.toString();
  }

  @Override
  public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    IndicesClient that = (IndicesClient) o;
    return delegate.equals(that.delegate);
  }
  
  @Override
  public int hashCode() {
    return delegate.hashCode();
  }

  public static final TypeArg __TYPE_ARG = new TypeArg<>(    obj -> new IndicesClient((io.reactiverse.elasticsearch.client.IndicesClient) obj),
    IndicesClient::getDelegate
  );

  private final io.reactiverse.elasticsearch.client.IndicesClient delegate;
  
  public IndicesClient(io.reactiverse.elasticsearch.client.IndicesClient delegate) {
    this.delegate = delegate;
  }

  public IndicesClient(Object delegate) {
    this.delegate = (io.reactiverse.elasticsearch.client.IndicesClient)delegate;
  }

  public io.reactiverse.elasticsearch.client.IndicesClient getDelegate() {
    return delegate;
  }

  public void deleteAsync(org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest deleteIndexRequest, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.deleteAsync(deleteIndexRequest, options, handler);
  }

  public void deleteAsync(org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest deleteIndexRequest, org.elasticsearch.client.RequestOptions options) {
    deleteAsync(deleteIndexRequest, options, ar -> { });
  }

  public io.reactivex.Single rxDeleteAsync(org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest deleteIndexRequest, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      deleteAsync(deleteIndexRequest, options, $handler);
    });
  }

  public void createAsync(org.elasticsearch.client.indices.CreateIndexRequest createIndexRequest, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.createAsync(createIndexRequest, options, handler);
  }

  public void createAsync(org.elasticsearch.client.indices.CreateIndexRequest createIndexRequest, org.elasticsearch.client.RequestOptions options) {
    createAsync(createIndexRequest, options, ar -> { });
  }

  public io.reactivex.Single rxCreateAsync(org.elasticsearch.client.indices.CreateIndexRequest createIndexRequest, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      createAsync(createIndexRequest, options, $handler);
    });
  }

  public void createDataStreamAsync(org.elasticsearch.client.indices.CreateDataStreamRequest createDataStreamRequest, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.createDataStreamAsync(createDataStreamRequest, options, handler);
  }

  public void createDataStreamAsync(org.elasticsearch.client.indices.CreateDataStreamRequest createDataStreamRequest, org.elasticsearch.client.RequestOptions options) {
    createDataStreamAsync(createDataStreamRequest, options, ar -> { });
  }

  public io.reactivex.Single rxCreateDataStreamAsync(org.elasticsearch.client.indices.CreateDataStreamRequest createDataStreamRequest, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      createDataStreamAsync(createDataStreamRequest, options, $handler);
    });
  }

  public void deleteDataStreamAsync(org.elasticsearch.client.indices.DeleteDataStreamRequest deleteDataStreamRequest, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.deleteDataStreamAsync(deleteDataStreamRequest, options, handler);
  }

  public void deleteDataStreamAsync(org.elasticsearch.client.indices.DeleteDataStreamRequest deleteDataStreamRequest, org.elasticsearch.client.RequestOptions options) {
    deleteDataStreamAsync(deleteDataStreamRequest, options, ar -> { });
  }

  public io.reactivex.Single rxDeleteDataStreamAsync(org.elasticsearch.client.indices.DeleteDataStreamRequest deleteDataStreamRequest, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      deleteDataStreamAsync(deleteDataStreamRequest, options, $handler);
    });
  }

  public void getDataStreamAsync(org.elasticsearch.client.indices.GetDataStreamRequest dataStreamRequest, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.getDataStreamAsync(dataStreamRequest, options, handler);
  }

  public void getDataStreamAsync(org.elasticsearch.client.indices.GetDataStreamRequest dataStreamRequest, org.elasticsearch.client.RequestOptions options) {
    getDataStreamAsync(dataStreamRequest, options, ar -> { });
  }

  public io.reactivex.Single rxGetDataStreamAsync(org.elasticsearch.client.indices.GetDataStreamRequest dataStreamRequest, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      getDataStreamAsync(dataStreamRequest, options, $handler);
    });
  }

  public void dataStreamsStatsAsync(org.elasticsearch.client.indices.DataStreamsStatsRequest dataStreamsStatsRequest, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.dataStreamsStatsAsync(dataStreamsStatsRequest, options, handler);
  }

  public void dataStreamsStatsAsync(org.elasticsearch.client.indices.DataStreamsStatsRequest dataStreamsStatsRequest, org.elasticsearch.client.RequestOptions options) {
    dataStreamsStatsAsync(dataStreamsStatsRequest, options, ar -> { });
  }

  public io.reactivex.Single rxDataStreamsStatsAsync(org.elasticsearch.client.indices.DataStreamsStatsRequest dataStreamsStatsRequest, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      dataStreamsStatsAsync(dataStreamsStatsRequest, options, $handler);
    });
  }

  public void putMappingAsync(org.elasticsearch.client.indices.PutMappingRequest putMappingRequest, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.putMappingAsync(putMappingRequest, options, handler);
  }

  public void putMappingAsync(org.elasticsearch.client.indices.PutMappingRequest putMappingRequest, org.elasticsearch.client.RequestOptions options) {
    putMappingAsync(putMappingRequest, options, ar -> { });
  }

  public io.reactivex.Single rxPutMappingAsync(org.elasticsearch.client.indices.PutMappingRequest putMappingRequest, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      putMappingAsync(putMappingRequest, options, $handler);
    });
  }

  public void getMappingAsync(org.elasticsearch.client.indices.GetMappingsRequest getMappingsRequest, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.getMappingAsync(getMappingsRequest, options, handler);
  }

  public void getMappingAsync(org.elasticsearch.client.indices.GetMappingsRequest getMappingsRequest, org.elasticsearch.client.RequestOptions options) {
    getMappingAsync(getMappingsRequest, options, ar -> { });
  }

  public io.reactivex.Single rxGetMappingAsync(org.elasticsearch.client.indices.GetMappingsRequest getMappingsRequest, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      getMappingAsync(getMappingsRequest, options, $handler);
    });
  }

  public void getFieldMappingAsync(org.elasticsearch.client.indices.GetFieldMappingsRequest getFieldMappingsRequest, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.getFieldMappingAsync(getFieldMappingsRequest, options, handler);
  }

  public void getFieldMappingAsync(org.elasticsearch.client.indices.GetFieldMappingsRequest getFieldMappingsRequest, org.elasticsearch.client.RequestOptions options) {
    getFieldMappingAsync(getFieldMappingsRequest, options, ar -> { });
  }

  public io.reactivex.Single rxGetFieldMappingAsync(org.elasticsearch.client.indices.GetFieldMappingsRequest getFieldMappingsRequest, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      getFieldMappingAsync(getFieldMappingsRequest, options, $handler);
    });
  }

  public void updateAliasesAsync(org.elasticsearch.action.admin.indices.alias.IndicesAliasesRequest indicesAliasesRequest, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.updateAliasesAsync(indicesAliasesRequest, options, handler);
  }

  public void updateAliasesAsync(org.elasticsearch.action.admin.indices.alias.IndicesAliasesRequest indicesAliasesRequest, org.elasticsearch.client.RequestOptions options) {
    updateAliasesAsync(indicesAliasesRequest, options, ar -> { });
  }

  public io.reactivex.Single rxUpdateAliasesAsync(org.elasticsearch.action.admin.indices.alias.IndicesAliasesRequest indicesAliasesRequest, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      updateAliasesAsync(indicesAliasesRequest, options, $handler);
    });
  }

  public void openAsync(org.elasticsearch.action.admin.indices.open.OpenIndexRequest openIndexRequest, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.openAsync(openIndexRequest, options, handler);
  }

  public void openAsync(org.elasticsearch.action.admin.indices.open.OpenIndexRequest openIndexRequest, org.elasticsearch.client.RequestOptions options) {
    openAsync(openIndexRequest, options, ar -> { });
  }

  public io.reactivex.Single rxOpenAsync(org.elasticsearch.action.admin.indices.open.OpenIndexRequest openIndexRequest, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      openAsync(openIndexRequest, options, $handler);
    });
  }

  public org.elasticsearch.client.indices.CloseIndexResponse close(org.elasticsearch.client.indices.CloseIndexRequest closeIndexRequest, org.elasticsearch.client.RequestOptions options) { 
    org.elasticsearch.client.indices.CloseIndexResponse ret = delegate.close(closeIndexRequest, options);
    return ret;
  }

  public void closeAsync(org.elasticsearch.client.indices.CloseIndexRequest closeIndexRequest, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.closeAsync(closeIndexRequest, options, handler);
  }

  public void closeAsync(org.elasticsearch.client.indices.CloseIndexRequest closeIndexRequest, org.elasticsearch.client.RequestOptions options) {
    closeAsync(closeIndexRequest, options, ar -> { });
  }

  public io.reactivex.Single rxCloseAsync(org.elasticsearch.client.indices.CloseIndexRequest closeIndexRequest, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      closeAsync(closeIndexRequest, options, $handler);
    });
  }

  public void existsAliasAsync(org.elasticsearch.action.admin.indices.alias.get.GetAliasesRequest getAliasesRequest, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.existsAliasAsync(getAliasesRequest, options, handler);
  }

  public void existsAliasAsync(org.elasticsearch.action.admin.indices.alias.get.GetAliasesRequest getAliasesRequest, org.elasticsearch.client.RequestOptions options) {
    existsAliasAsync(getAliasesRequest, options, ar -> { });
  }

  public io.reactivex.Single rxExistsAliasAsync(org.elasticsearch.action.admin.indices.alias.get.GetAliasesRequest getAliasesRequest, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      existsAliasAsync(getAliasesRequest, options, $handler);
    });
  }

  public void refreshAsync(org.elasticsearch.action.admin.indices.refresh.RefreshRequest refreshRequest, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.refreshAsync(refreshRequest, options, handler);
  }

  public void refreshAsync(org.elasticsearch.action.admin.indices.refresh.RefreshRequest refreshRequest, org.elasticsearch.client.RequestOptions options) {
    refreshAsync(refreshRequest, options, ar -> { });
  }

  public io.reactivex.Single rxRefreshAsync(org.elasticsearch.action.admin.indices.refresh.RefreshRequest refreshRequest, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      refreshAsync(refreshRequest, options, $handler);
    });
  }

  public void flushAsync(org.elasticsearch.action.admin.indices.flush.FlushRequest flushRequest, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.flushAsync(flushRequest, options, handler);
  }

  public void flushAsync(org.elasticsearch.action.admin.indices.flush.FlushRequest flushRequest, org.elasticsearch.client.RequestOptions options) {
    flushAsync(flushRequest, options, ar -> { });
  }

  public io.reactivex.Single rxFlushAsync(org.elasticsearch.action.admin.indices.flush.FlushRequest flushRequest, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      flushAsync(flushRequest, options, $handler);
    });
  }

  public void getSettingsAsync(org.elasticsearch.action.admin.indices.settings.get.GetSettingsRequest getSettingsRequest, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.getSettingsAsync(getSettingsRequest, options, handler);
  }

  public void getSettingsAsync(org.elasticsearch.action.admin.indices.settings.get.GetSettingsRequest getSettingsRequest, org.elasticsearch.client.RequestOptions options) {
    getSettingsAsync(getSettingsRequest, options, ar -> { });
  }

  public io.reactivex.Single rxGetSettingsAsync(org.elasticsearch.action.admin.indices.settings.get.GetSettingsRequest getSettingsRequest, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      getSettingsAsync(getSettingsRequest, options, $handler);
    });
  }

  public void getAsync(org.elasticsearch.client.indices.GetIndexRequest getIndexRequest, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.getAsync(getIndexRequest, options, handler);
  }

  public void getAsync(org.elasticsearch.client.indices.GetIndexRequest getIndexRequest, org.elasticsearch.client.RequestOptions options) {
    getAsync(getIndexRequest, options, ar -> { });
  }

  public io.reactivex.Single rxGetAsync(org.elasticsearch.client.indices.GetIndexRequest getIndexRequest, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      getAsync(getIndexRequest, options, $handler);
    });
  }

  public void forcemergeAsync(org.elasticsearch.action.admin.indices.forcemerge.ForceMergeRequest forceMergeRequest, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.forcemergeAsync(forceMergeRequest, options, handler);
  }

  public void forcemergeAsync(org.elasticsearch.action.admin.indices.forcemerge.ForceMergeRequest forceMergeRequest, org.elasticsearch.client.RequestOptions options) {
    forcemergeAsync(forceMergeRequest, options, ar -> { });
  }

  public io.reactivex.Single rxForcemergeAsync(org.elasticsearch.action.admin.indices.forcemerge.ForceMergeRequest forceMergeRequest, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      forcemergeAsync(forceMergeRequest, options, $handler);
    });
  }

  public void clearCacheAsync(org.elasticsearch.action.admin.indices.cache.clear.ClearIndicesCacheRequest clearIndicesCacheRequest, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.clearCacheAsync(clearIndicesCacheRequest, options, handler);
  }

  public void clearCacheAsync(org.elasticsearch.action.admin.indices.cache.clear.ClearIndicesCacheRequest clearIndicesCacheRequest, org.elasticsearch.client.RequestOptions options) {
    clearCacheAsync(clearIndicesCacheRequest, options, ar -> { });
  }

  public io.reactivex.Single rxClearCacheAsync(org.elasticsearch.action.admin.indices.cache.clear.ClearIndicesCacheRequest clearIndicesCacheRequest, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      clearCacheAsync(clearIndicesCacheRequest, options, $handler);
    });
  }

  public void existsAsync(org.elasticsearch.client.indices.GetIndexRequest request, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.existsAsync(request, options, handler);
  }

  public void existsAsync(org.elasticsearch.client.indices.GetIndexRequest request, org.elasticsearch.client.RequestOptions options) {
    existsAsync(request, options, ar -> { });
  }

  public io.reactivex.Single rxExistsAsync(org.elasticsearch.client.indices.GetIndexRequest request, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      existsAsync(request, options, $handler);
    });
  }

  public void shrinkAsync(org.elasticsearch.client.indices.ResizeRequest resizeRequest, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.shrinkAsync(resizeRequest, options, handler);
  }

  public void shrinkAsync(org.elasticsearch.client.indices.ResizeRequest resizeRequest, org.elasticsearch.client.RequestOptions options) {
    shrinkAsync(resizeRequest, options, ar -> { });
  }

  public io.reactivex.Single rxShrinkAsync(org.elasticsearch.client.indices.ResizeRequest resizeRequest, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      shrinkAsync(resizeRequest, options, $handler);
    });
  }

  public void splitAsync(org.elasticsearch.client.indices.ResizeRequest resizeRequest, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.splitAsync(resizeRequest, options, handler);
  }

  public void splitAsync(org.elasticsearch.client.indices.ResizeRequest resizeRequest, org.elasticsearch.client.RequestOptions options) {
    splitAsync(resizeRequest, options, ar -> { });
  }

  public io.reactivex.Single rxSplitAsync(org.elasticsearch.client.indices.ResizeRequest resizeRequest, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      splitAsync(resizeRequest, options, $handler);
    });
  }

  public void cloneAsync(org.elasticsearch.client.indices.ResizeRequest resizeRequest, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.cloneAsync(resizeRequest, options, handler);
  }

  public void cloneAsync(org.elasticsearch.client.indices.ResizeRequest resizeRequest, org.elasticsearch.client.RequestOptions options) {
    cloneAsync(resizeRequest, options, ar -> { });
  }

  public io.reactivex.Single rxCloneAsync(org.elasticsearch.client.indices.ResizeRequest resizeRequest, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      cloneAsync(resizeRequest, options, $handler);
    });
  }

  public void rolloverAsync(org.elasticsearch.client.indices.rollover.RolloverRequest rolloverRequest, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.rolloverAsync(rolloverRequest, options, handler);
  }

  public void rolloverAsync(org.elasticsearch.client.indices.rollover.RolloverRequest rolloverRequest, org.elasticsearch.client.RequestOptions options) {
    rolloverAsync(rolloverRequest, options, ar -> { });
  }

  public io.reactivex.Single rxRolloverAsync(org.elasticsearch.client.indices.rollover.RolloverRequest rolloverRequest, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      rolloverAsync(rolloverRequest, options, $handler);
    });
  }

  public void getAliasAsync(org.elasticsearch.action.admin.indices.alias.get.GetAliasesRequest getAliasesRequest, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.getAliasAsync(getAliasesRequest, options, handler);
  }

  public void getAliasAsync(org.elasticsearch.action.admin.indices.alias.get.GetAliasesRequest getAliasesRequest, org.elasticsearch.client.RequestOptions options) {
    getAliasAsync(getAliasesRequest, options, ar -> { });
  }

  public io.reactivex.Single rxGetAliasAsync(org.elasticsearch.action.admin.indices.alias.get.GetAliasesRequest getAliasesRequest, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      getAliasAsync(getAliasesRequest, options, $handler);
    });
  }

  public void putSettingsAsync(org.elasticsearch.action.admin.indices.settings.put.UpdateSettingsRequest updateSettingsRequest, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.putSettingsAsync(updateSettingsRequest, options, handler);
  }

  public void putSettingsAsync(org.elasticsearch.action.admin.indices.settings.put.UpdateSettingsRequest updateSettingsRequest, org.elasticsearch.client.RequestOptions options) {
    putSettingsAsync(updateSettingsRequest, options, ar -> { });
  }

  public io.reactivex.Single rxPutSettingsAsync(org.elasticsearch.action.admin.indices.settings.put.UpdateSettingsRequest updateSettingsRequest, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      putSettingsAsync(updateSettingsRequest, options, $handler);
    });
  }

  public void putTemplateAsync(org.elasticsearch.client.indices.PutIndexTemplateRequest putIndexTemplateRequest, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.putTemplateAsync(putIndexTemplateRequest, options, handler);
  }

  public void putTemplateAsync(org.elasticsearch.client.indices.PutIndexTemplateRequest putIndexTemplateRequest, org.elasticsearch.client.RequestOptions options) {
    putTemplateAsync(putIndexTemplateRequest, options, ar -> { });
  }

  public io.reactivex.Single rxPutTemplateAsync(org.elasticsearch.client.indices.PutIndexTemplateRequest putIndexTemplateRequest, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      putTemplateAsync(putIndexTemplateRequest, options, $handler);
    });
  }

  public void putIndexTemplateAsync(org.elasticsearch.client.indices.PutComposableIndexTemplateRequest putIndexTemplateRequest, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.putIndexTemplateAsync(putIndexTemplateRequest, options, handler);
  }

  public void putIndexTemplateAsync(org.elasticsearch.client.indices.PutComposableIndexTemplateRequest putIndexTemplateRequest, org.elasticsearch.client.RequestOptions options) {
    putIndexTemplateAsync(putIndexTemplateRequest, options, ar -> { });
  }

  public io.reactivex.Single rxPutIndexTemplateAsync(org.elasticsearch.client.indices.PutComposableIndexTemplateRequest putIndexTemplateRequest, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      putIndexTemplateAsync(putIndexTemplateRequest, options, $handler);
    });
  }

  public void simulateIndexTemplateAsync(org.elasticsearch.client.indices.SimulateIndexTemplateRequest simulateIndexTemplateRequest, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.simulateIndexTemplateAsync(simulateIndexTemplateRequest, options, handler);
  }

  public void simulateIndexTemplateAsync(org.elasticsearch.client.indices.SimulateIndexTemplateRequest simulateIndexTemplateRequest, org.elasticsearch.client.RequestOptions options) {
    simulateIndexTemplateAsync(simulateIndexTemplateRequest, options, ar -> { });
  }

  public io.reactivex.Single rxSimulateIndexTemplateAsync(org.elasticsearch.client.indices.SimulateIndexTemplateRequest simulateIndexTemplateRequest, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      simulateIndexTemplateAsync(simulateIndexTemplateRequest, options, $handler);
    });
  }

  public void validateQueryAsync(org.elasticsearch.action.admin.indices.validate.query.ValidateQueryRequest validateQueryRequest, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.validateQueryAsync(validateQueryRequest, options, handler);
  }

  public void validateQueryAsync(org.elasticsearch.action.admin.indices.validate.query.ValidateQueryRequest validateQueryRequest, org.elasticsearch.client.RequestOptions options) {
    validateQueryAsync(validateQueryRequest, options, ar -> { });
  }

  public io.reactivex.Single rxValidateQueryAsync(org.elasticsearch.action.admin.indices.validate.query.ValidateQueryRequest validateQueryRequest, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      validateQueryAsync(validateQueryRequest, options, $handler);
    });
  }

  public void getIndexTemplateAsync(org.elasticsearch.client.indices.GetComposableIndexTemplateRequest getIndexTemplatesRequest, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.getIndexTemplateAsync(getIndexTemplatesRequest, options, handler);
  }

  public void getIndexTemplateAsync(org.elasticsearch.client.indices.GetComposableIndexTemplateRequest getIndexTemplatesRequest, org.elasticsearch.client.RequestOptions options) {
    getIndexTemplateAsync(getIndexTemplatesRequest, options, ar -> { });
  }

  public io.reactivex.Single rxGetIndexTemplateAsync(org.elasticsearch.client.indices.GetComposableIndexTemplateRequest getIndexTemplatesRequest, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      getIndexTemplateAsync(getIndexTemplatesRequest, options, $handler);
    });
  }

  public void getIndexTemplateAsync(org.elasticsearch.client.indices.GetIndexTemplatesRequest getIndexTemplatesRequest, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.getIndexTemplateAsync(getIndexTemplatesRequest, options, handler);
  }

  public void getIndexTemplateAsync(org.elasticsearch.client.indices.GetIndexTemplatesRequest getIndexTemplatesRequest, org.elasticsearch.client.RequestOptions options) {
    getIndexTemplateAsync(getIndexTemplatesRequest, options, ar -> { });
  }

  public io.reactivex.Single rxGetIndexTemplateAsync(org.elasticsearch.client.indices.GetIndexTemplatesRequest getIndexTemplatesRequest, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      getIndexTemplateAsync(getIndexTemplatesRequest, options, $handler);
    });
  }

  public void existsTemplateAsync(org.elasticsearch.client.indices.IndexTemplatesExistRequest indexTemplatesExistRequest, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.existsTemplateAsync(indexTemplatesExistRequest, options, handler);
  }

  public void existsTemplateAsync(org.elasticsearch.client.indices.IndexTemplatesExistRequest indexTemplatesExistRequest, org.elasticsearch.client.RequestOptions options) {
    existsTemplateAsync(indexTemplatesExistRequest, options, ar -> { });
  }

  public io.reactivex.Single rxExistsTemplateAsync(org.elasticsearch.client.indices.IndexTemplatesExistRequest indexTemplatesExistRequest, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      existsTemplateAsync(indexTemplatesExistRequest, options, $handler);
    });
  }

  public void existsIndexTemplateAsync(org.elasticsearch.client.indices.ComposableIndexTemplateExistRequest indexTemplatesExistRequest, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.existsIndexTemplateAsync(indexTemplatesExistRequest, options, handler);
  }

  public void existsIndexTemplateAsync(org.elasticsearch.client.indices.ComposableIndexTemplateExistRequest indexTemplatesExistRequest, org.elasticsearch.client.RequestOptions options) {
    existsIndexTemplateAsync(indexTemplatesExistRequest, options, ar -> { });
  }

  public io.reactivex.Single rxExistsIndexTemplateAsync(org.elasticsearch.client.indices.ComposableIndexTemplateExistRequest indexTemplatesExistRequest, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      existsIndexTemplateAsync(indexTemplatesExistRequest, options, $handler);
    });
  }

  public void analyzeAsync(org.elasticsearch.client.indices.AnalyzeRequest request, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.analyzeAsync(request, options, handler);
  }

  public void analyzeAsync(org.elasticsearch.client.indices.AnalyzeRequest request, org.elasticsearch.client.RequestOptions options) {
    analyzeAsync(request, options, ar -> { });
  }

  public io.reactivex.Single rxAnalyzeAsync(org.elasticsearch.client.indices.AnalyzeRequest request, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      analyzeAsync(request, options, $handler);
    });
  }

  public void freezeAsync(org.elasticsearch.client.indices.FreezeIndexRequest request, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.freezeAsync(request, options, handler);
  }

  public void freezeAsync(org.elasticsearch.client.indices.FreezeIndexRequest request, org.elasticsearch.client.RequestOptions options) {
    freezeAsync(request, options, ar -> { });
  }

  public io.reactivex.Single rxFreezeAsync(org.elasticsearch.client.indices.FreezeIndexRequest request, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      freezeAsync(request, options, $handler);
    });
  }

  public void unfreezeAsync(org.elasticsearch.client.indices.UnfreezeIndexRequest request, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.unfreezeAsync(request, options, handler);
  }

  public void unfreezeAsync(org.elasticsearch.client.indices.UnfreezeIndexRequest request, org.elasticsearch.client.RequestOptions options) {
    unfreezeAsync(request, options, ar -> { });
  }

  public io.reactivex.Single rxUnfreezeAsync(org.elasticsearch.client.indices.UnfreezeIndexRequest request, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      unfreezeAsync(request, options, $handler);
    });
  }

  public void deleteTemplateAsync(org.elasticsearch.action.admin.indices.template.delete.DeleteIndexTemplateRequest request, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.deleteTemplateAsync(request, options, handler);
  }

  public void deleteTemplateAsync(org.elasticsearch.action.admin.indices.template.delete.DeleteIndexTemplateRequest request, org.elasticsearch.client.RequestOptions options) {
    deleteTemplateAsync(request, options, ar -> { });
  }

  public io.reactivex.Single rxDeleteTemplateAsync(org.elasticsearch.action.admin.indices.template.delete.DeleteIndexTemplateRequest request, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      deleteTemplateAsync(request, options, $handler);
    });
  }

  public void deleteIndexTemplateAsync(org.elasticsearch.client.indices.DeleteComposableIndexTemplateRequest request, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.deleteIndexTemplateAsync(request, options, handler);
  }

  public void deleteIndexTemplateAsync(org.elasticsearch.client.indices.DeleteComposableIndexTemplateRequest request, org.elasticsearch.client.RequestOptions options) {
    deleteIndexTemplateAsync(request, options, ar -> { });
  }

  public io.reactivex.Single rxDeleteIndexTemplateAsync(org.elasticsearch.client.indices.DeleteComposableIndexTemplateRequest request, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      deleteIndexTemplateAsync(request, options, $handler);
    });
  }

  public void reloadAnalyzersAsync(org.elasticsearch.client.indices.ReloadAnalyzersRequest request, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.reloadAnalyzersAsync(request, options, handler);
  }

  public void reloadAnalyzersAsync(org.elasticsearch.client.indices.ReloadAnalyzersRequest request, org.elasticsearch.client.RequestOptions options) {
    reloadAnalyzersAsync(request, options, ar -> { });
  }

  public io.reactivex.Single rxReloadAnalyzersAsync(org.elasticsearch.client.indices.ReloadAnalyzersRequest request, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      reloadAnalyzersAsync(request, options, $handler);
    });
  }

  public void deleteAliasAsync(org.elasticsearch.client.indices.DeleteAliasRequest request, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.deleteAliasAsync(request, options, handler);
  }

  public void deleteAliasAsync(org.elasticsearch.client.indices.DeleteAliasRequest request, org.elasticsearch.client.RequestOptions options) {
    deleteAliasAsync(request, options, ar -> { });
  }

  public io.reactivex.Single rxDeleteAliasAsync(org.elasticsearch.client.indices.DeleteAliasRequest request, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      deleteAliasAsync(request, options, $handler);
    });
  }

  public static IndicesClient newInstance(io.reactiverse.elasticsearch.client.IndicesClient arg) {
    return arg != null ? new IndicesClient(arg) : null;
  }

}