• Home
• io.reactiverse
• opensearch-rest-high-level-client-rxjava3
• 0.9.0
• 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.opensearch.client.rxjava3.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.opensearch.client.rxjava3;

import io.vertx.rxjava3.RxHelper;
import io.vertx.rxjava3.ObservableHelper;
import io.vertx.rxjava3.FlowableHelper;
import io.vertx.rxjava3.impl.AsyncResultMaybe;
import io.vertx.rxjava3.impl.AsyncResultSingle;
import io.vertx.rxjava3.impl.AsyncResultCompletable;
import io.vertx.rxjava3.WriteStreamObserver;
import io.vertx.rxjava3.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.opensearch.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.opensearch.client.RestHighLevelClient) obj),
    RestHighLevelClient::getDelegate
  );

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

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

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

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

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

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

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

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

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

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

  public io.reactivex.rxjava3.core.Single bulkAsync(org.opensearch.action.bulk.BulkRequest bulkRequest, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxBulkAsync(bulkRequest, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

  public io.reactivex.rxjava3.core.Single reindexAsync(org.opensearch.index.reindex.ReindexRequest reindexRequest, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxReindexAsync(reindexRequest, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

  public io.reactivex.rxjava3.core.Single updateByQueryAsync(org.opensearch.index.reindex.UpdateByQueryRequest updateByQueryRequest, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxUpdateByQueryAsync(updateByQueryRequest, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

  public io.reactivex.rxjava3.core.Single deleteByQueryAsync(org.opensearch.index.reindex.DeleteByQueryRequest deleteByQueryRequest, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxDeleteByQueryAsync(deleteByQueryRequest, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

  public io.reactivex.rxjava3.core.Single deleteByQueryRethrottleAsync(org.opensearch.client.RethrottleRequest rethrottleRequest, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxDeleteByQueryRethrottleAsync(rethrottleRequest, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

  public io.reactivex.rxjava3.core.Single updateByQueryRethrottleAsync(org.opensearch.client.RethrottleRequest rethrottleRequest, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxUpdateByQueryRethrottleAsync(rethrottleRequest, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

  public io.reactivex.rxjava3.core.Single reindexRethrottleAsync(org.opensearch.client.RethrottleRequest rethrottleRequest, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxReindexRethrottleAsync(rethrottleRequest, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

  public io.reactivex.rxjava3.core.Single getAsync(org.opensearch.action.get.GetRequest getRequest, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxGetAsync(getRequest, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

  public io.reactivex.rxjava3.core.Single mgetAsync(org.opensearch.action.get.MultiGetRequest multiGetRequest, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxMgetAsync(multiGetRequest, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

  public io.reactivex.rxjava3.core.Single existsAsync(org.opensearch.action.get.GetRequest getRequest, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxExistsAsync(getRequest, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

  public io.reactivex.rxjava3.core.Single existsSourceAsync(org.opensearch.client.core.GetSourceRequest getSourceRequest, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxExistsSourceAsync(getSourceRequest, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

  public io.reactivex.rxjava3.core.Single getSourceAsync(org.opensearch.client.core.GetSourceRequest getSourceRequest, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxGetSourceAsync(getSourceRequest, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

  public io.reactivex.rxjava3.core.Single indexAsync(org.opensearch.action.index.IndexRequest indexRequest, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxIndexAsync(indexRequest, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

  public io.reactivex.rxjava3.core.Single countAsync(org.opensearch.client.core.CountRequest countRequest, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxCountAsync(countRequest, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

  public io.reactivex.rxjava3.core.Single updateAsync(org.opensearch.action.update.UpdateRequest updateRequest, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxUpdateAsync(updateRequest, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

  public io.reactivex.rxjava3.core.Single deleteAsync(org.opensearch.action.delete.DeleteRequest deleteRequest, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxDeleteAsync(deleteRequest, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

  public io.reactivex.rxjava3.core.Single searchAsync(org.opensearch.action.search.SearchRequest searchRequest, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxSearchAsync(searchRequest, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

  public io.reactivex.rxjava3.core.Single msearchAsync(org.opensearch.action.search.MultiSearchRequest searchRequest, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxMsearchAsync(searchRequest, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

  public io.reactivex.rxjava3.core.Single scrollAsync(org.opensearch.action.search.SearchScrollRequest searchScrollRequest, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxScrollAsync(searchScrollRequest, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

  public io.reactivex.rxjava3.core.Single createPitAsync(org.opensearch.action.search.CreatePitRequest createPitRequest, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxCreatePitAsync(createPitRequest, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

  public io.reactivex.rxjava3.core.Single rxCreatePitAsync(org.opensearch.action.search.CreatePitRequest createPitRequest, org.opensearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle( handler -> {
      delegate.createPitAsync(createPitRequest, options, handler);
    });
  }

  public io.reactivex.rxjava3.core.Single deletePitAsync(org.opensearch.action.search.DeletePitRequest deletePitRequest, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxDeletePitAsync(deletePitRequest, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

  public io.reactivex.rxjava3.core.Single rxDeletePitAsync(org.opensearch.action.search.DeletePitRequest deletePitRequest, org.opensearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle( handler -> {
      delegate.deletePitAsync(deletePitRequest, options, handler);
    });
  }

  public io.reactivex.rxjava3.core.Single deleteAllPitsAsync(org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxDeleteAllPitsAsync(options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

  public io.reactivex.rxjava3.core.Single rxDeleteAllPitsAsync(org.opensearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle( handler -> {
      delegate.deleteAllPitsAsync(options, handler);
    });
  }

  public io.reactivex.rxjava3.core.Single getAllPitsAsync(org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxGetAllPitsAsync(options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

  public io.reactivex.rxjava3.core.Single rxGetAllPitsAsync(org.opensearch.client.RequestOptions options) { 
    return AsyncResultSingle.toSingle( handler -> {
      delegate.getAllPitsAsync(options, handler);
    });
  }

  public io.reactivex.rxjava3.core.Single clearScrollAsync(org.opensearch.action.search.ClearScrollRequest clearScrollRequest, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxClearScrollAsync(clearScrollRequest, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

  public io.reactivex.rxjava3.core.Single searchTemplateAsync(org.opensearch.script.mustache.SearchTemplateRequest searchTemplateRequest, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxSearchTemplateAsync(searchTemplateRequest, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

  public io.reactivex.rxjava3.core.Single explainAsync(org.opensearch.action.explain.ExplainRequest explainRequest, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxExplainAsync(explainRequest, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

  public io.reactivex.rxjava3.core.Single termvectorsAsync(org.opensearch.client.core.TermVectorsRequest request, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxTermvectorsAsync(request, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

  public io.reactivex.rxjava3.core.Single mtermvectorsAsync(org.opensearch.client.core.MultiTermVectorsRequest request, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxMtermvectorsAsync(request, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

  public io.reactivex.rxjava3.core.Single msearchTemplateAsync(org.opensearch.script.mustache.MultiSearchTemplateRequest multiSearchTemplateRequest, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxMsearchTemplateAsync(multiSearchTemplateRequest, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

  public io.reactivex.rxjava3.core.Single rankEvalAsync(org.opensearch.index.rankeval.RankEvalRequest rankEvalRequest, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxRankEvalAsync(rankEvalRequest, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

  public io.reactivex.rxjava3.core.Single getScriptAsync(org.opensearch.action.admin.cluster.storedscripts.GetStoredScriptRequest request, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxGetScriptAsync(request, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

  public io.reactivex.rxjava3.core.Single deleteScriptAsync(org.opensearch.action.admin.cluster.storedscripts.DeleteStoredScriptRequest request, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxDeleteScriptAsync(request, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

  public io.reactivex.rxjava3.core.Single putScriptAsync(org.opensearch.action.admin.cluster.storedscripts.PutStoredScriptRequest putStoredScriptRequest, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxPutScriptAsync(putStoredScriptRequest, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

  public io.reactivex.rxjava3.core.Single fieldCapsAsync(org.opensearch.action.fieldcaps.FieldCapabilitiesRequest fieldCapabilitiesRequest, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxFieldCapsAsync(fieldCapabilitiesRequest, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

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

}