• Home
• io.reactiverse
• opensearch-rest-high-level-client-rxjava3
• 0.9.0
• 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.opensearch.client.rxjava3.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.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.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.opensearch.client.IndicesClient) obj),
    IndicesClient::getDelegate
  );

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

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

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

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

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

  public io.reactivex.rxjava3.core.Single createAsync(org.opensearch.client.indices.CreateIndexRequest createIndexRequest, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxCreateAsync(createIndexRequest, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

  public io.reactivex.rxjava3.core.Single createDataStreamAsync(org.opensearch.client.indices.CreateDataStreamRequest createDataStreamRequest, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxCreateDataStreamAsync(createDataStreamRequest, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

  public io.reactivex.rxjava3.core.Single deleteDataStreamAsync(org.opensearch.client.indices.DeleteDataStreamRequest deleteDataStreamRequest, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxDeleteDataStreamAsync(deleteDataStreamRequest, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

  public io.reactivex.rxjava3.core.Single getDataStreamAsync(org.opensearch.client.indices.GetDataStreamRequest dataStreamRequest, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxGetDataStreamAsync(dataStreamRequest, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

  public io.reactivex.rxjava3.core.Single dataStreamsStatsAsync(org.opensearch.client.indices.DataStreamsStatsRequest dataStreamsStatsRequest, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxDataStreamsStatsAsync(dataStreamsStatsRequest, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

  public io.reactivex.rxjava3.core.Single putMappingAsync(org.opensearch.client.indices.PutMappingRequest putMappingRequest, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxPutMappingAsync(putMappingRequest, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

  public io.reactivex.rxjava3.core.Single getMappingAsync(org.opensearch.client.indices.GetMappingsRequest getMappingsRequest, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxGetMappingAsync(getMappingsRequest, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

  public io.reactivex.rxjava3.core.Single getFieldMappingAsync(org.opensearch.client.indices.GetFieldMappingsRequest getFieldMappingsRequest, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxGetFieldMappingAsync(getFieldMappingsRequest, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

  public io.reactivex.rxjava3.core.Single updateAliasesAsync(org.opensearch.action.admin.indices.alias.IndicesAliasesRequest indicesAliasesRequest, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxUpdateAliasesAsync(indicesAliasesRequest, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

  public io.reactivex.rxjava3.core.Single openAsync(org.opensearch.action.admin.indices.open.OpenIndexRequest openIndexRequest, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxOpenAsync(openIndexRequest, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

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

  public io.reactivex.rxjava3.core.Single closeAsync(org.opensearch.client.indices.CloseIndexRequest closeIndexRequest, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxCloseAsync(closeIndexRequest, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

  public io.reactivex.rxjava3.core.Single existsAliasAsync(org.opensearch.action.admin.indices.alias.get.GetAliasesRequest getAliasesRequest, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxExistsAliasAsync(getAliasesRequest, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

  public io.reactivex.rxjava3.core.Single refreshAsync(org.opensearch.action.admin.indices.refresh.RefreshRequest refreshRequest, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxRefreshAsync(refreshRequest, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

  public io.reactivex.rxjava3.core.Single flushAsync(org.opensearch.action.admin.indices.flush.FlushRequest flushRequest, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxFlushAsync(flushRequest, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

  public io.reactivex.rxjava3.core.Single getSettingsAsync(org.opensearch.action.admin.indices.settings.get.GetSettingsRequest getSettingsRequest, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxGetSettingsAsync(getSettingsRequest, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

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

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

  public io.reactivex.rxjava3.core.Single forcemergeAsync(org.opensearch.action.admin.indices.forcemerge.ForceMergeRequest forceMergeRequest, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxForcemergeAsync(forceMergeRequest, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

  public io.reactivex.rxjava3.core.Single clearCacheAsync(org.opensearch.action.admin.indices.cache.clear.ClearIndicesCacheRequest clearIndicesCacheRequest, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxClearCacheAsync(clearIndicesCacheRequest, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

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

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

  public io.reactivex.rxjava3.core.Single shrinkAsync(org.opensearch.client.indices.ResizeRequest resizeRequest, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxShrinkAsync(resizeRequest, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

  public io.reactivex.rxjava3.core.Single splitAsync(org.opensearch.client.indices.ResizeRequest resizeRequest, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxSplitAsync(resizeRequest, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

  public io.reactivex.rxjava3.core.Single cloneAsync(org.opensearch.client.indices.ResizeRequest resizeRequest, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxCloneAsync(resizeRequest, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

  public io.reactivex.rxjava3.core.Single rolloverAsync(org.opensearch.client.indices.rollover.RolloverRequest rolloverRequest, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxRolloverAsync(rolloverRequest, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

  public io.reactivex.rxjava3.core.Single getAliasAsync(org.opensearch.action.admin.indices.alias.get.GetAliasesRequest getAliasesRequest, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxGetAliasAsync(getAliasesRequest, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

  public io.reactivex.rxjava3.core.Single putSettingsAsync(org.opensearch.action.admin.indices.settings.put.UpdateSettingsRequest updateSettingsRequest, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxPutSettingsAsync(updateSettingsRequest, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

  public io.reactivex.rxjava3.core.Single putTemplateAsync(org.opensearch.client.indices.PutIndexTemplateRequest putIndexTemplateRequest, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxPutTemplateAsync(putIndexTemplateRequest, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

  public io.reactivex.rxjava3.core.Single putIndexTemplateAsync(org.opensearch.client.indices.PutComposableIndexTemplateRequest putIndexTemplateRequest, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxPutIndexTemplateAsync(putIndexTemplateRequest, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

  public io.reactivex.rxjava3.core.Single simulateIndexTemplateAsync(org.opensearch.client.indices.SimulateIndexTemplateRequest simulateIndexTemplateRequest, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxSimulateIndexTemplateAsync(simulateIndexTemplateRequest, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

  public io.reactivex.rxjava3.core.Single validateQueryAsync(org.opensearch.action.admin.indices.validate.query.ValidateQueryRequest validateQueryRequest, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxValidateQueryAsync(validateQueryRequest, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

  public io.reactivex.rxjava3.core.Single getIndexTemplateAsync(org.opensearch.client.indices.GetComposableIndexTemplateRequest getIndexTemplatesRequest, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxGetIndexTemplateAsync(getIndexTemplatesRequest, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

  public io.reactivex.rxjava3.core.Single getIndexTemplateAsync(org.opensearch.client.indices.GetIndexTemplatesRequest getIndexTemplatesRequest, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxGetIndexTemplateAsync(getIndexTemplatesRequest, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

  public io.reactivex.rxjava3.core.Single existsTemplateAsync(org.opensearch.client.indices.IndexTemplatesExistRequest indexTemplatesExistRequest, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxExistsTemplateAsync(indexTemplatesExistRequest, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

  public io.reactivex.rxjava3.core.Single existsIndexTemplateAsync(org.opensearch.client.indices.ComposableIndexTemplateExistRequest indexTemplatesExistRequest, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxExistsIndexTemplateAsync(indexTemplatesExistRequest, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

  public io.reactivex.rxjava3.core.Single analyzeAsync(org.opensearch.client.indices.AnalyzeRequest request, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxAnalyzeAsync(request, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

  public io.reactivex.rxjava3.core.Single deleteTemplateAsync(org.opensearch.action.admin.indices.template.delete.DeleteIndexTemplateRequest request, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxDeleteTemplateAsync(request, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

  public io.reactivex.rxjava3.core.Single deleteIndexTemplateAsync(org.opensearch.client.indices.DeleteComposableIndexTemplateRequest request, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxDeleteIndexTemplateAsync(request, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

  public io.reactivex.rxjava3.core.Single deleteAliasAsync(org.opensearch.client.indices.DeleteAliasRequest request, org.opensearch.client.RequestOptions options) { 
    io.reactivex.rxjava3.core.Single ret = rxDeleteAliasAsync(request, options);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.SingleHelper.nullObserver());
    return ret;
  }

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

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

}