• Home
• io.reactiverse
• elasticsearch-client-rxjava2
• 0.9.0-ec7.10.1
• source code
• RestHighLevelClient.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.RestHighLevelClient 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.RestHighLevelClient.class)
public class RestHighLevelClient {

  @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;
    RestHighLevelClient that = (RestHighLevelClient) o;
    return delegate.equals(that.delegate);
  }
  
  @Override
  public int hashCode() {
    return delegate.hashCode();
  }

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

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

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

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

  public static io.reactiverse.elasticsearch.client.reactivex.RestHighLevelClient create(io.vertx.reactivex.core.Vertx vertx, org.elasticsearch.client.RestClientBuilder restClientBuilder) { 
    io.reactiverse.elasticsearch.client.reactivex.RestHighLevelClient ret = io.reactiverse.elasticsearch.client.reactivex.RestHighLevelClient.newInstance((io.reactiverse.elasticsearch.client.RestHighLevelClient)io.reactiverse.elasticsearch.client.RestHighLevelClient.create(vertx.getDelegate(), restClientBuilder));
    return ret;
  }

  public void close() { 
    delegate.close();
  }

  public io.reactiverse.elasticsearch.client.reactivex.IndicesClient indices() { 
    io.reactiverse.elasticsearch.client.reactivex.IndicesClient ret = io.reactiverse.elasticsearch.client.reactivex.IndicesClient.newInstance((io.reactiverse.elasticsearch.client.IndicesClient)delegate.indices());
    return ret;
  }

  public io.reactiverse.elasticsearch.client.reactivex.ClusterClient cluster() { 
    io.reactiverse.elasticsearch.client.reactivex.ClusterClient ret = io.reactiverse.elasticsearch.client.reactivex.ClusterClient.newInstance((io.reactiverse.elasticsearch.client.ClusterClient)delegate.cluster());
    return ret;
  }

  public io.reactiverse.elasticsearch.client.reactivex.IngestClient ingest() { 
    io.reactiverse.elasticsearch.client.reactivex.IngestClient ret = io.reactiverse.elasticsearch.client.reactivex.IngestClient.newInstance((io.reactiverse.elasticsearch.client.IngestClient)delegate.ingest());
    return ret;
  }

  public io.reactiverse.elasticsearch.client.reactivex.SnapshotClient snapshot() { 
    io.reactiverse.elasticsearch.client.reactivex.SnapshotClient ret = io.reactiverse.elasticsearch.client.reactivex.SnapshotClient.newInstance((io.reactiverse.elasticsearch.client.SnapshotClient)delegate.snapshot());
    return ret;
  }

  public io.reactiverse.elasticsearch.client.reactivex.RollupClient rollup() { 
    io.reactiverse.elasticsearch.client.reactivex.RollupClient ret = io.reactiverse.elasticsearch.client.reactivex.RollupClient.newInstance((io.reactiverse.elasticsearch.client.RollupClient)delegate.rollup());
    return ret;
  }

  public io.reactiverse.elasticsearch.client.reactivex.CcrClient ccr() { 
    io.reactiverse.elasticsearch.client.reactivex.CcrClient ret = io.reactiverse.elasticsearch.client.reactivex.CcrClient.newInstance((io.reactiverse.elasticsearch.client.CcrClient)delegate.ccr());
    return ret;
  }

  public io.reactiverse.elasticsearch.client.reactivex.TasksClient tasks() { 
    io.reactiverse.elasticsearch.client.reactivex.TasksClient ret = io.reactiverse.elasticsearch.client.reactivex.TasksClient.newInstance((io.reactiverse.elasticsearch.client.TasksClient)delegate.tasks());
    return ret;
  }

  public io.reactiverse.elasticsearch.client.reactivex.XPackClient xpack() { 
    io.reactiverse.elasticsearch.client.reactivex.XPackClient ret = io.reactiverse.elasticsearch.client.reactivex.XPackClient.newInstance((io.reactiverse.elasticsearch.client.XPackClient)delegate.xpack());
    return ret;
  }

  public io.reactiverse.elasticsearch.client.reactivex.WatcherClient watcher() { 
    io.reactiverse.elasticsearch.client.reactivex.WatcherClient ret = io.reactiverse.elasticsearch.client.reactivex.WatcherClient.newInstance((io.reactiverse.elasticsearch.client.WatcherClient)delegate.watcher());
    return ret;
  }

  public io.reactiverse.elasticsearch.client.reactivex.GraphClient graph() { 
    io.reactiverse.elasticsearch.client.reactivex.GraphClient ret = io.reactiverse.elasticsearch.client.reactivex.GraphClient.newInstance((io.reactiverse.elasticsearch.client.GraphClient)delegate.graph());
    return ret;
  }

  public io.reactiverse.elasticsearch.client.reactivex.LicenseClient license() { 
    io.reactiverse.elasticsearch.client.reactivex.LicenseClient ret = io.reactiverse.elasticsearch.client.reactivex.LicenseClient.newInstance((io.reactiverse.elasticsearch.client.LicenseClient)delegate.license());
    return ret;
  }

  public io.reactiverse.elasticsearch.client.reactivex.IndexLifecycleClient indexLifecycle() { 
    io.reactiverse.elasticsearch.client.reactivex.IndexLifecycleClient ret = io.reactiverse.elasticsearch.client.reactivex.IndexLifecycleClient.newInstance((io.reactiverse.elasticsearch.client.IndexLifecycleClient)delegate.indexLifecycle());
    return ret;
  }

  public io.reactiverse.elasticsearch.client.reactivex.AsyncSearchClient asyncSearch() { 
    io.reactiverse.elasticsearch.client.reactivex.AsyncSearchClient ret = io.reactiverse.elasticsearch.client.reactivex.AsyncSearchClient.newInstance((io.reactiverse.elasticsearch.client.AsyncSearchClient)delegate.asyncSearch());
    return ret;
  }

  public io.reactiverse.elasticsearch.client.reactivex.MachineLearningClient machineLearning() { 
    io.reactiverse.elasticsearch.client.reactivex.MachineLearningClient ret = io.reactiverse.elasticsearch.client.reactivex.MachineLearningClient.newInstance((io.reactiverse.elasticsearch.client.MachineLearningClient)delegate.machineLearning());
    return ret;
  }

  public io.reactiverse.elasticsearch.client.reactivex.SecurityClient security() { 
    io.reactiverse.elasticsearch.client.reactivex.SecurityClient ret = io.reactiverse.elasticsearch.client.reactivex.SecurityClient.newInstance((io.reactiverse.elasticsearch.client.SecurityClient)delegate.security());
    return ret;
  }

  public io.reactiverse.elasticsearch.client.reactivex.TransformClient transform() { 
    io.reactiverse.elasticsearch.client.reactivex.TransformClient ret = io.reactiverse.elasticsearch.client.reactivex.TransformClient.newInstance((io.reactiverse.elasticsearch.client.TransformClient)delegate.transform());
    return ret;
  }

  public io.reactiverse.elasticsearch.client.reactivex.EnrichClient enrich() { 
    io.reactiverse.elasticsearch.client.reactivex.EnrichClient ret = io.reactiverse.elasticsearch.client.reactivex.EnrichClient.newInstance((io.reactiverse.elasticsearch.client.EnrichClient)delegate.enrich());
    return ret;
  }

  public io.reactiverse.elasticsearch.client.reactivex.EqlClient eql() { 
    io.reactiverse.elasticsearch.client.reactivex.EqlClient ret = io.reactiverse.elasticsearch.client.reactivex.EqlClient.newInstance((io.reactiverse.elasticsearch.client.EqlClient)delegate.eql());
    return ret;
  }

  public void bulkAsync(org.elasticsearch.action.bulk.BulkRequest bulkRequest, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.bulkAsync(bulkRequest, options, handler);
  }

  public void bulkAsync(org.elasticsearch.action.bulk.BulkRequest bulkRequest, org.elasticsearch.client.RequestOptions options) {
    bulkAsync(bulkRequest, options, ar -> { });
  }

  public io.reactivex.Single rxBulkAsync(org.elasticsearch.action.bulk.BulkRequest bulkRequest, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      bulkAsync(bulkRequest, options, $handler);
    });
  }

  public void reindexAsync(org.elasticsearch.index.reindex.ReindexRequest reindexRequest, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.reindexAsync(reindexRequest, options, handler);
  }

  public void reindexAsync(org.elasticsearch.index.reindex.ReindexRequest reindexRequest, org.elasticsearch.client.RequestOptions options) {
    reindexAsync(reindexRequest, options, ar -> { });
  }

  public io.reactivex.Single rxReindexAsync(org.elasticsearch.index.reindex.ReindexRequest reindexRequest, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      reindexAsync(reindexRequest, options, $handler);
    });
  }

  public void updateByQueryAsync(org.elasticsearch.index.reindex.UpdateByQueryRequest updateByQueryRequest, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.updateByQueryAsync(updateByQueryRequest, options, handler);
  }

  public void updateByQueryAsync(org.elasticsearch.index.reindex.UpdateByQueryRequest updateByQueryRequest, org.elasticsearch.client.RequestOptions options) {
    updateByQueryAsync(updateByQueryRequest, options, ar -> { });
  }

  public io.reactivex.Single rxUpdateByQueryAsync(org.elasticsearch.index.reindex.UpdateByQueryRequest updateByQueryRequest, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      updateByQueryAsync(updateByQueryRequest, options, $handler);
    });
  }

  public void deleteByQueryAsync(org.elasticsearch.index.reindex.DeleteByQueryRequest deleteByQueryRequest, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.deleteByQueryAsync(deleteByQueryRequest, options, handler);
  }

  public void deleteByQueryAsync(org.elasticsearch.index.reindex.DeleteByQueryRequest deleteByQueryRequest, org.elasticsearch.client.RequestOptions options) {
    deleteByQueryAsync(deleteByQueryRequest, options, ar -> { });
  }

  public io.reactivex.Single rxDeleteByQueryAsync(org.elasticsearch.index.reindex.DeleteByQueryRequest deleteByQueryRequest, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      deleteByQueryAsync(deleteByQueryRequest, options, $handler);
    });
  }

  public void deleteByQueryRethrottleAsync(org.elasticsearch.client.RethrottleRequest rethrottleRequest, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.deleteByQueryRethrottleAsync(rethrottleRequest, options, handler);
  }

  public void deleteByQueryRethrottleAsync(org.elasticsearch.client.RethrottleRequest rethrottleRequest, org.elasticsearch.client.RequestOptions options) {
    deleteByQueryRethrottleAsync(rethrottleRequest, options, ar -> { });
  }

  public io.reactivex.Single rxDeleteByQueryRethrottleAsync(org.elasticsearch.client.RethrottleRequest rethrottleRequest, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      deleteByQueryRethrottleAsync(rethrottleRequest, options, $handler);
    });
  }

  public void updateByQueryRethrottleAsync(org.elasticsearch.client.RethrottleRequest rethrottleRequest, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.updateByQueryRethrottleAsync(rethrottleRequest, options, handler);
  }

  public void updateByQueryRethrottleAsync(org.elasticsearch.client.RethrottleRequest rethrottleRequest, org.elasticsearch.client.RequestOptions options) {
    updateByQueryRethrottleAsync(rethrottleRequest, options, ar -> { });
  }

  public io.reactivex.Single rxUpdateByQueryRethrottleAsync(org.elasticsearch.client.RethrottleRequest rethrottleRequest, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      updateByQueryRethrottleAsync(rethrottleRequest, options, $handler);
    });
  }

  public void reindexRethrottleAsync(org.elasticsearch.client.RethrottleRequest rethrottleRequest, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.reindexRethrottleAsync(rethrottleRequest, options, handler);
  }

  public void reindexRethrottleAsync(org.elasticsearch.client.RethrottleRequest rethrottleRequest, org.elasticsearch.client.RequestOptions options) {
    reindexRethrottleAsync(rethrottleRequest, options, ar -> { });
  }

  public io.reactivex.Single rxReindexRethrottleAsync(org.elasticsearch.client.RethrottleRequest rethrottleRequest, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      reindexRethrottleAsync(rethrottleRequest, options, $handler);
    });
  }

  public void getAsync(org.elasticsearch.action.get.GetRequest getRequest, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.getAsync(getRequest, options, handler);
  }

  public void getAsync(org.elasticsearch.action.get.GetRequest getRequest, org.elasticsearch.client.RequestOptions options) {
    getAsync(getRequest, options, ar -> { });
  }

  public io.reactivex.Single rxGetAsync(org.elasticsearch.action.get.GetRequest getRequest, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      getAsync(getRequest, options, $handler);
    });
  }

  public void mgetAsync(org.elasticsearch.action.get.MultiGetRequest multiGetRequest, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.mgetAsync(multiGetRequest, options, handler);
  }

  public void mgetAsync(org.elasticsearch.action.get.MultiGetRequest multiGetRequest, org.elasticsearch.client.RequestOptions options) {
    mgetAsync(multiGetRequest, options, ar -> { });
  }

  public io.reactivex.Single rxMgetAsync(org.elasticsearch.action.get.MultiGetRequest multiGetRequest, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      mgetAsync(multiGetRequest, options, $handler);
    });
  }

  public void existsAsync(org.elasticsearch.action.get.GetRequest getRequest, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.existsAsync(getRequest, options, handler);
  }

  public void existsAsync(org.elasticsearch.action.get.GetRequest getRequest, org.elasticsearch.client.RequestOptions options) {
    existsAsync(getRequest, options, ar -> { });
  }

  public io.reactivex.Single rxExistsAsync(org.elasticsearch.action.get.GetRequest getRequest, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      existsAsync(getRequest, options, $handler);
    });
  }

  public void existsSourceAsync(org.elasticsearch.client.core.GetSourceRequest getSourceRequest, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.existsSourceAsync(getSourceRequest, options, handler);
  }

  public void existsSourceAsync(org.elasticsearch.client.core.GetSourceRequest getSourceRequest, org.elasticsearch.client.RequestOptions options) {
    existsSourceAsync(getSourceRequest, options, ar -> { });
  }

  public io.reactivex.Single rxExistsSourceAsync(org.elasticsearch.client.core.GetSourceRequest getSourceRequest, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      existsSourceAsync(getSourceRequest, options, $handler);
    });
  }

  public void getSourceAsync(org.elasticsearch.client.core.GetSourceRequest getSourceRequest, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.getSourceAsync(getSourceRequest, options, handler);
  }

  public void getSourceAsync(org.elasticsearch.client.core.GetSourceRequest getSourceRequest, org.elasticsearch.client.RequestOptions options) {
    getSourceAsync(getSourceRequest, options, ar -> { });
  }

  public io.reactivex.Single rxGetSourceAsync(org.elasticsearch.client.core.GetSourceRequest getSourceRequest, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      getSourceAsync(getSourceRequest, options, $handler);
    });
  }

  public void indexAsync(org.elasticsearch.action.index.IndexRequest indexRequest, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.indexAsync(indexRequest, options, handler);
  }

  public void indexAsync(org.elasticsearch.action.index.IndexRequest indexRequest, org.elasticsearch.client.RequestOptions options) {
    indexAsync(indexRequest, options, ar -> { });
  }

  public io.reactivex.Single rxIndexAsync(org.elasticsearch.action.index.IndexRequest indexRequest, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      indexAsync(indexRequest, options, $handler);
    });
  }

  public void countAsync(org.elasticsearch.client.core.CountRequest countRequest, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.countAsync(countRequest, options, handler);
  }

  public void countAsync(org.elasticsearch.client.core.CountRequest countRequest, org.elasticsearch.client.RequestOptions options) {
    countAsync(countRequest, options, ar -> { });
  }

  public io.reactivex.Single rxCountAsync(org.elasticsearch.client.core.CountRequest countRequest, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      countAsync(countRequest, options, $handler);
    });
  }

  public void updateAsync(org.elasticsearch.action.update.UpdateRequest updateRequest, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.updateAsync(updateRequest, options, handler);
  }

  public void updateAsync(org.elasticsearch.action.update.UpdateRequest updateRequest, org.elasticsearch.client.RequestOptions options) {
    updateAsync(updateRequest, options, ar -> { });
  }

  public io.reactivex.Single rxUpdateAsync(org.elasticsearch.action.update.UpdateRequest updateRequest, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      updateAsync(updateRequest, options, $handler);
    });
  }

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

  public void deleteAsync(org.elasticsearch.action.delete.DeleteRequest deleteRequest, org.elasticsearch.client.RequestOptions options) {
    deleteAsync(deleteRequest, options, ar -> { });
  }

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

  public void searchAsync(org.elasticsearch.action.search.SearchRequest searchRequest, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.searchAsync(searchRequest, options, handler);
  }

  public void searchAsync(org.elasticsearch.action.search.SearchRequest searchRequest, org.elasticsearch.client.RequestOptions options) {
    searchAsync(searchRequest, options, ar -> { });
  }

  public io.reactivex.Single rxSearchAsync(org.elasticsearch.action.search.SearchRequest searchRequest, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      searchAsync(searchRequest, options, $handler);
    });
  }

  public void msearchAsync(org.elasticsearch.action.search.MultiSearchRequest searchRequest, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.msearchAsync(searchRequest, options, handler);
  }

  public void msearchAsync(org.elasticsearch.action.search.MultiSearchRequest searchRequest, org.elasticsearch.client.RequestOptions options) {
    msearchAsync(searchRequest, options, ar -> { });
  }

  public io.reactivex.Single rxMsearchAsync(org.elasticsearch.action.search.MultiSearchRequest searchRequest, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      msearchAsync(searchRequest, options, $handler);
    });
  }

  public void scrollAsync(org.elasticsearch.action.search.SearchScrollRequest searchScrollRequest, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.scrollAsync(searchScrollRequest, options, handler);
  }

  public void scrollAsync(org.elasticsearch.action.search.SearchScrollRequest searchScrollRequest, org.elasticsearch.client.RequestOptions options) {
    scrollAsync(searchScrollRequest, options, ar -> { });
  }

  public io.reactivex.Single rxScrollAsync(org.elasticsearch.action.search.SearchScrollRequest searchScrollRequest, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      scrollAsync(searchScrollRequest, options, $handler);
    });
  }

  public void clearScrollAsync(org.elasticsearch.action.search.ClearScrollRequest clearScrollRequest, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.clearScrollAsync(clearScrollRequest, options, handler);
  }

  public void clearScrollAsync(org.elasticsearch.action.search.ClearScrollRequest clearScrollRequest, org.elasticsearch.client.RequestOptions options) {
    clearScrollAsync(clearScrollRequest, options, ar -> { });
  }

  public io.reactivex.Single rxClearScrollAsync(org.elasticsearch.action.search.ClearScrollRequest clearScrollRequest, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      clearScrollAsync(clearScrollRequest, options, $handler);
    });
  }

  public void searchTemplateAsync(org.elasticsearch.script.mustache.SearchTemplateRequest searchTemplateRequest, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.searchTemplateAsync(searchTemplateRequest, options, handler);
  }

  public void searchTemplateAsync(org.elasticsearch.script.mustache.SearchTemplateRequest searchTemplateRequest, org.elasticsearch.client.RequestOptions options) {
    searchTemplateAsync(searchTemplateRequest, options, ar -> { });
  }

  public io.reactivex.Single rxSearchTemplateAsync(org.elasticsearch.script.mustache.SearchTemplateRequest searchTemplateRequest, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      searchTemplateAsync(searchTemplateRequest, options, $handler);
    });
  }

  public void explainAsync(org.elasticsearch.action.explain.ExplainRequest explainRequest, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.explainAsync(explainRequest, options, handler);
  }

  public void explainAsync(org.elasticsearch.action.explain.ExplainRequest explainRequest, org.elasticsearch.client.RequestOptions options) {
    explainAsync(explainRequest, options, ar -> { });
  }

  public io.reactivex.Single rxExplainAsync(org.elasticsearch.action.explain.ExplainRequest explainRequest, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      explainAsync(explainRequest, options, $handler);
    });
  }

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

  public void termvectorsAsync(org.elasticsearch.client.core.TermVectorsRequest request, org.elasticsearch.client.RequestOptions options) {
    termvectorsAsync(request, options, ar -> { });
  }

  public io.reactivex.Single rxTermvectorsAsync(org.elasticsearch.client.core.TermVectorsRequest request, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      termvectorsAsync(request, options, $handler);
    });
  }

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

  public void mtermvectorsAsync(org.elasticsearch.client.core.MultiTermVectorsRequest request, org.elasticsearch.client.RequestOptions options) {
    mtermvectorsAsync(request, options, ar -> { });
  }

  public io.reactivex.Single rxMtermvectorsAsync(org.elasticsearch.client.core.MultiTermVectorsRequest request, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      mtermvectorsAsync(request, options, $handler);
    });
  }

  public void msearchTemplateAsync(org.elasticsearch.script.mustache.MultiSearchTemplateRequest multiSearchTemplateRequest, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.msearchTemplateAsync(multiSearchTemplateRequest, options, handler);
  }

  public void msearchTemplateAsync(org.elasticsearch.script.mustache.MultiSearchTemplateRequest multiSearchTemplateRequest, org.elasticsearch.client.RequestOptions options) {
    msearchTemplateAsync(multiSearchTemplateRequest, options, ar -> { });
  }

  public io.reactivex.Single rxMsearchTemplateAsync(org.elasticsearch.script.mustache.MultiSearchTemplateRequest multiSearchTemplateRequest, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      msearchTemplateAsync(multiSearchTemplateRequest, options, $handler);
    });
  }

  public void rankEvalAsync(org.elasticsearch.index.rankeval.RankEvalRequest rankEvalRequest, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.rankEvalAsync(rankEvalRequest, options, handler);
  }

  public void rankEvalAsync(org.elasticsearch.index.rankeval.RankEvalRequest rankEvalRequest, org.elasticsearch.client.RequestOptions options) {
    rankEvalAsync(rankEvalRequest, options, ar -> { });
  }

  public io.reactivex.Single rxRankEvalAsync(org.elasticsearch.index.rankeval.RankEvalRequest rankEvalRequest, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      rankEvalAsync(rankEvalRequest, options, $handler);
    });
  }

  public void getScriptAsync(org.elasticsearch.action.admin.cluster.storedscripts.GetStoredScriptRequest request, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.getScriptAsync(request, options, handler);
  }

  public void getScriptAsync(org.elasticsearch.action.admin.cluster.storedscripts.GetStoredScriptRequest request, org.elasticsearch.client.RequestOptions options) {
    getScriptAsync(request, options, ar -> { });
  }

  public io.reactivex.Single rxGetScriptAsync(org.elasticsearch.action.admin.cluster.storedscripts.GetStoredScriptRequest request, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      getScriptAsync(request, options, $handler);
    });
  }

  public void deleteScriptAsync(org.elasticsearch.action.admin.cluster.storedscripts.DeleteStoredScriptRequest request, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.deleteScriptAsync(request, options, handler);
  }

  public void deleteScriptAsync(org.elasticsearch.action.admin.cluster.storedscripts.DeleteStoredScriptRequest request, org.elasticsearch.client.RequestOptions options) {
    deleteScriptAsync(request, options, ar -> { });
  }

  public io.reactivex.Single rxDeleteScriptAsync(org.elasticsearch.action.admin.cluster.storedscripts.DeleteStoredScriptRequest request, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      deleteScriptAsync(request, options, $handler);
    });
  }

  public void putScriptAsync(org.elasticsearch.action.admin.cluster.storedscripts.PutStoredScriptRequest putStoredScriptRequest, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.putScriptAsync(putStoredScriptRequest, options, handler);
  }

  public void putScriptAsync(org.elasticsearch.action.admin.cluster.storedscripts.PutStoredScriptRequest putStoredScriptRequest, org.elasticsearch.client.RequestOptions options) {
    putScriptAsync(putStoredScriptRequest, options, ar -> { });
  }

  public io.reactivex.Single rxPutScriptAsync(org.elasticsearch.action.admin.cluster.storedscripts.PutStoredScriptRequest putStoredScriptRequest, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      putScriptAsync(putStoredScriptRequest, options, $handler);
    });
  }

  public void fieldCapsAsync(org.elasticsearch.action.fieldcaps.FieldCapabilitiesRequest fieldCapabilitiesRequest, org.elasticsearch.client.RequestOptions options, io.vertx.core.Handler> handler) { 
    delegate.fieldCapsAsync(fieldCapabilitiesRequest, options, handler);
  }

  public void fieldCapsAsync(org.elasticsearch.action.fieldcaps.FieldCapabilitiesRequest fieldCapabilitiesRequest, org.elasticsearch.client.RequestOptions options) {
    fieldCapsAsync(fieldCapabilitiesRequest, options, ar -> { });
  }

  public io.reactivex.Single rxFieldCapsAsync(org.elasticsearch.action.fieldcaps.FieldCapabilitiesRequest fieldCapabilitiesRequest, org.elasticsearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle($handler -> {
      fieldCapsAsync(fieldCapabilitiesRequest, options, $handler);
    });
  }

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

}