OpenSearchServerlessClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/opensearchserverless/OpenSearchServerlessServiceClientModel.h>
#include <aws/opensearchserverless/OpenSearchServerless_EXPORTS.h>
 
namespace Aws {
namespace OpenSearchServerless {
class AWS_OPENSEARCHSERVERLESS_API OpenSearchServerlessClient
    : public Aws::Client::AWSJsonClient,
      public Aws::Client::ClientWithAsyncTemplateMethods<OpenSearchServerlessClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef OpenSearchServerlessClientConfiguration ClientConfigurationType;
  typedef OpenSearchServerlessEndpointProvider EndpointProviderType;
 
  OpenSearchServerlessClient(const Aws::OpenSearchServerless::OpenSearchServerlessClientConfiguration& clientConfiguration =
                                 Aws::OpenSearchServerless::OpenSearchServerlessClientConfiguration(),
                             std::shared_ptr<OpenSearchServerlessEndpointProviderBase> endpointProvider = nullptr);
 
  OpenSearchServerlessClient(const Aws::Auth::AWSCredentials& credentials,
                             std::shared_ptr<OpenSearchServerlessEndpointProviderBase> endpointProvider = nullptr,
                             const Aws::OpenSearchServerless::OpenSearchServerlessClientConfiguration& clientConfiguration =
                                 Aws::OpenSearchServerless::OpenSearchServerlessClientConfiguration());
 
  OpenSearchServerlessClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                             std::shared_ptr<OpenSearchServerlessEndpointProviderBase> endpointProvider = nullptr,
                             const Aws::OpenSearchServerless::OpenSearchServerlessClientConfiguration& clientConfiguration =
                                 Aws::OpenSearchServerless::OpenSearchServerlessClientConfiguration());
 
  /* Legacy constructors due deprecation */
  OpenSearchServerlessClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  OpenSearchServerlessClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  OpenSearchServerlessClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                             const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~OpenSearchServerlessClient();
 
  virtual Model::BatchGetCollectionOutcome BatchGetCollection(const Model::BatchGetCollectionRequest& request = {}) const;
 
  template <typename BatchGetCollectionRequestT = Model::BatchGetCollectionRequest>
  Model::BatchGetCollectionOutcomeCallable BatchGetCollectionCallable(const BatchGetCollectionRequestT& request = {}) const {
    return SubmitCallable(&OpenSearchServerlessClient::BatchGetCollection, request);
  }
 
  template <typename BatchGetCollectionRequestT = Model::BatchGetCollectionRequest>
  void BatchGetCollectionAsync(const BatchGetCollectionResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const BatchGetCollectionRequestT& request = {}) const {
    return SubmitAsync(&OpenSearchServerlessClient::BatchGetCollection, request, handler, context);
  }
 
  virtual Model::BatchGetEffectiveLifecyclePolicyOutcome BatchGetEffectiveLifecyclePolicy(
      const Model::BatchGetEffectiveLifecyclePolicyRequest& request) const;
 
  template <typename BatchGetEffectiveLifecyclePolicyRequestT = Model::BatchGetEffectiveLifecyclePolicyRequest>
  Model::BatchGetEffectiveLifecyclePolicyOutcomeCallable BatchGetEffectiveLifecyclePolicyCallable(
      const BatchGetEffectiveLifecyclePolicyRequestT& request) const {
    return SubmitCallable(&OpenSearchServerlessClient::BatchGetEffectiveLifecyclePolicy, request);
  }
 
  template <typename BatchGetEffectiveLifecyclePolicyRequestT = Model::BatchGetEffectiveLifecyclePolicyRequest>
  void BatchGetEffectiveLifecyclePolicyAsync(const BatchGetEffectiveLifecyclePolicyRequestT& request,
                                             const BatchGetEffectiveLifecyclePolicyResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServerlessClient::BatchGetEffectiveLifecyclePolicy, request, handler, context);
  }
 
  virtual Model::BatchGetLifecyclePolicyOutcome BatchGetLifecyclePolicy(const Model::BatchGetLifecyclePolicyRequest& request) const;
 
  template <typename BatchGetLifecyclePolicyRequestT = Model::BatchGetLifecyclePolicyRequest>
  Model::BatchGetLifecyclePolicyOutcomeCallable BatchGetLifecyclePolicyCallable(const BatchGetLifecyclePolicyRequestT& request) const {
    return SubmitCallable(&OpenSearchServerlessClient::BatchGetLifecyclePolicy, request);
  }
 
  template <typename BatchGetLifecyclePolicyRequestT = Model::BatchGetLifecyclePolicyRequest>
  void BatchGetLifecyclePolicyAsync(const BatchGetLifecyclePolicyRequestT& request,
                                    const BatchGetLifecyclePolicyResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServerlessClient::BatchGetLifecyclePolicy, request, handler, context);
  }
 
  virtual Model::BatchGetVpcEndpointOutcome BatchGetVpcEndpoint(const Model::BatchGetVpcEndpointRequest& request) const;
 
  template <typename BatchGetVpcEndpointRequestT = Model::BatchGetVpcEndpointRequest>
  Model::BatchGetVpcEndpointOutcomeCallable BatchGetVpcEndpointCallable(const BatchGetVpcEndpointRequestT& request) const {
    return SubmitCallable(&OpenSearchServerlessClient::BatchGetVpcEndpoint, request);
  }
 
  template <typename BatchGetVpcEndpointRequestT = Model::BatchGetVpcEndpointRequest>
  void BatchGetVpcEndpointAsync(const BatchGetVpcEndpointRequestT& request, const BatchGetVpcEndpointResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServerlessClient::BatchGetVpcEndpoint, request, handler, context);
  }
 
  virtual Model::CreateAccessPolicyOutcome CreateAccessPolicy(const Model::CreateAccessPolicyRequest& request) const;
 
  template <typename CreateAccessPolicyRequestT = Model::CreateAccessPolicyRequest>
  Model::CreateAccessPolicyOutcomeCallable CreateAccessPolicyCallable(const CreateAccessPolicyRequestT& request) const {
    return SubmitCallable(&OpenSearchServerlessClient::CreateAccessPolicy, request);
  }
 
  template <typename CreateAccessPolicyRequestT = Model::CreateAccessPolicyRequest>
  void CreateAccessPolicyAsync(const CreateAccessPolicyRequestT& request, const CreateAccessPolicyResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServerlessClient::CreateAccessPolicy, request, handler, context);
  }
 
  virtual Model::CreateCollectionOutcome CreateCollection(const Model::CreateCollectionRequest& request) const;
 
  template <typename CreateCollectionRequestT = Model::CreateCollectionRequest>
  Model::CreateCollectionOutcomeCallable CreateCollectionCallable(const CreateCollectionRequestT& request) const {
    return SubmitCallable(&OpenSearchServerlessClient::CreateCollection, request);
  }
 
  template <typename CreateCollectionRequestT = Model::CreateCollectionRequest>
  void CreateCollectionAsync(const CreateCollectionRequestT& request, const CreateCollectionResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServerlessClient::CreateCollection, request, handler, context);
  }
 
  virtual Model::CreateIndexOutcome CreateIndex(const Model::CreateIndexRequest& request) const;
 
  template <typename CreateIndexRequestT = Model::CreateIndexRequest>
  Model::CreateIndexOutcomeCallable CreateIndexCallable(const CreateIndexRequestT& request) const {
    return SubmitCallable(&OpenSearchServerlessClient::CreateIndex, request);
  }
 
  template <typename CreateIndexRequestT = Model::CreateIndexRequest>
  void CreateIndexAsync(const CreateIndexRequestT& request, const CreateIndexResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServerlessClient::CreateIndex, request, handler, context);
  }
 
  virtual Model::CreateLifecyclePolicyOutcome CreateLifecyclePolicy(const Model::CreateLifecyclePolicyRequest& request) const;
 
  template <typename CreateLifecyclePolicyRequestT = Model::CreateLifecyclePolicyRequest>
  Model::CreateLifecyclePolicyOutcomeCallable CreateLifecyclePolicyCallable(const CreateLifecyclePolicyRequestT& request) const {
    return SubmitCallable(&OpenSearchServerlessClient::CreateLifecyclePolicy, request);
  }
 
  template <typename CreateLifecyclePolicyRequestT = Model::CreateLifecyclePolicyRequest>
  void CreateLifecyclePolicyAsync(const CreateLifecyclePolicyRequestT& request, const CreateLifecyclePolicyResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServerlessClient::CreateLifecyclePolicy, request, handler, context);
  }
 
  virtual Model::CreateSecurityConfigOutcome CreateSecurityConfig(const Model::CreateSecurityConfigRequest& request) const;
 
  template <typename CreateSecurityConfigRequestT = Model::CreateSecurityConfigRequest>
  Model::CreateSecurityConfigOutcomeCallable CreateSecurityConfigCallable(const CreateSecurityConfigRequestT& request) const {
    return SubmitCallable(&OpenSearchServerlessClient::CreateSecurityConfig, request);
  }
 
  template <typename CreateSecurityConfigRequestT = Model::CreateSecurityConfigRequest>
  void CreateSecurityConfigAsync(const CreateSecurityConfigRequestT& request, const CreateSecurityConfigResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServerlessClient::CreateSecurityConfig, request, handler, context);
  }
 
  virtual Model::CreateSecurityPolicyOutcome CreateSecurityPolicy(const Model::CreateSecurityPolicyRequest& request) const;
 
  template <typename CreateSecurityPolicyRequestT = Model::CreateSecurityPolicyRequest>
  Model::CreateSecurityPolicyOutcomeCallable CreateSecurityPolicyCallable(const CreateSecurityPolicyRequestT& request) const {
    return SubmitCallable(&OpenSearchServerlessClient::CreateSecurityPolicy, request);
  }
 
  template <typename CreateSecurityPolicyRequestT = Model::CreateSecurityPolicyRequest>
  void CreateSecurityPolicyAsync(const CreateSecurityPolicyRequestT& request, const CreateSecurityPolicyResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServerlessClient::CreateSecurityPolicy, request, handler, context);
  }
 
  virtual Model::CreateVpcEndpointOutcome CreateVpcEndpoint(const Model::CreateVpcEndpointRequest& request) const;
 
  template <typename CreateVpcEndpointRequestT = Model::CreateVpcEndpointRequest>
  Model::CreateVpcEndpointOutcomeCallable CreateVpcEndpointCallable(const CreateVpcEndpointRequestT& request) const {
    return SubmitCallable(&OpenSearchServerlessClient::CreateVpcEndpoint, request);
  }
 
  template <typename CreateVpcEndpointRequestT = Model::CreateVpcEndpointRequest>
  void CreateVpcEndpointAsync(const CreateVpcEndpointRequestT& request, const CreateVpcEndpointResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServerlessClient::CreateVpcEndpoint, request, handler, context);
  }
 
  virtual Model::DeleteAccessPolicyOutcome DeleteAccessPolicy(const Model::DeleteAccessPolicyRequest& request) const;
 
  template <typename DeleteAccessPolicyRequestT = Model::DeleteAccessPolicyRequest>
  Model::DeleteAccessPolicyOutcomeCallable DeleteAccessPolicyCallable(const DeleteAccessPolicyRequestT& request) const {
    return SubmitCallable(&OpenSearchServerlessClient::DeleteAccessPolicy, request);
  }
 
  template <typename DeleteAccessPolicyRequestT = Model::DeleteAccessPolicyRequest>
  void DeleteAccessPolicyAsync(const DeleteAccessPolicyRequestT& request, const DeleteAccessPolicyResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServerlessClient::DeleteAccessPolicy, request, handler, context);
  }
 
  virtual Model::DeleteCollectionOutcome DeleteCollection(const Model::DeleteCollectionRequest& request) const;
 
  template <typename DeleteCollectionRequestT = Model::DeleteCollectionRequest>
  Model::DeleteCollectionOutcomeCallable DeleteCollectionCallable(const DeleteCollectionRequestT& request) const {
    return SubmitCallable(&OpenSearchServerlessClient::DeleteCollection, request);
  }
 
  template <typename DeleteCollectionRequestT = Model::DeleteCollectionRequest>
  void DeleteCollectionAsync(const DeleteCollectionRequestT& request, const DeleteCollectionResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServerlessClient::DeleteCollection, request, handler, context);
  }
 
  virtual Model::DeleteIndexOutcome DeleteIndex(const Model::DeleteIndexRequest& request) const;
 
  template <typename DeleteIndexRequestT = Model::DeleteIndexRequest>
  Model::DeleteIndexOutcomeCallable DeleteIndexCallable(const DeleteIndexRequestT& request) const {
    return SubmitCallable(&OpenSearchServerlessClient::DeleteIndex, request);
  }
 
  template <typename DeleteIndexRequestT = Model::DeleteIndexRequest>
  void DeleteIndexAsync(const DeleteIndexRequestT& request, const DeleteIndexResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServerlessClient::DeleteIndex, request, handler, context);
  }
 
  virtual Model::DeleteLifecyclePolicyOutcome DeleteLifecyclePolicy(const Model::DeleteLifecyclePolicyRequest& request) const;
 
  template <typename DeleteLifecyclePolicyRequestT = Model::DeleteLifecyclePolicyRequest>
  Model::DeleteLifecyclePolicyOutcomeCallable DeleteLifecyclePolicyCallable(const DeleteLifecyclePolicyRequestT& request) const {
    return SubmitCallable(&OpenSearchServerlessClient::DeleteLifecyclePolicy, request);
  }
 
  template <typename DeleteLifecyclePolicyRequestT = Model::DeleteLifecyclePolicyRequest>
  void DeleteLifecyclePolicyAsync(const DeleteLifecyclePolicyRequestT& request, const DeleteLifecyclePolicyResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServerlessClient::DeleteLifecyclePolicy, request, handler, context);
  }
 
  virtual Model::DeleteSecurityConfigOutcome DeleteSecurityConfig(const Model::DeleteSecurityConfigRequest& request) const;
 
  template <typename DeleteSecurityConfigRequestT = Model::DeleteSecurityConfigRequest>
  Model::DeleteSecurityConfigOutcomeCallable DeleteSecurityConfigCallable(const DeleteSecurityConfigRequestT& request) const {
    return SubmitCallable(&OpenSearchServerlessClient::DeleteSecurityConfig, request);
  }
 
  template <typename DeleteSecurityConfigRequestT = Model::DeleteSecurityConfigRequest>
  void DeleteSecurityConfigAsync(const DeleteSecurityConfigRequestT& request, const DeleteSecurityConfigResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServerlessClient::DeleteSecurityConfig, request, handler, context);
  }
 
  virtual Model::DeleteSecurityPolicyOutcome DeleteSecurityPolicy(const Model::DeleteSecurityPolicyRequest& request) const;
 
  template <typename DeleteSecurityPolicyRequestT = Model::DeleteSecurityPolicyRequest>
  Model::DeleteSecurityPolicyOutcomeCallable DeleteSecurityPolicyCallable(const DeleteSecurityPolicyRequestT& request) const {
    return SubmitCallable(&OpenSearchServerlessClient::DeleteSecurityPolicy, request);
  }
 
  template <typename DeleteSecurityPolicyRequestT = Model::DeleteSecurityPolicyRequest>
  void DeleteSecurityPolicyAsync(const DeleteSecurityPolicyRequestT& request, const DeleteSecurityPolicyResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServerlessClient::DeleteSecurityPolicy, request, handler, context);
  }
 
  virtual Model::DeleteVpcEndpointOutcome DeleteVpcEndpoint(const Model::DeleteVpcEndpointRequest& request) const;
 
  template <typename DeleteVpcEndpointRequestT = Model::DeleteVpcEndpointRequest>
  Model::DeleteVpcEndpointOutcomeCallable DeleteVpcEndpointCallable(const DeleteVpcEndpointRequestT& request) const {
    return SubmitCallable(&OpenSearchServerlessClient::DeleteVpcEndpoint, request);
  }
 
  template <typename DeleteVpcEndpointRequestT = Model::DeleteVpcEndpointRequest>
  void DeleteVpcEndpointAsync(const DeleteVpcEndpointRequestT& request, const DeleteVpcEndpointResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServerlessClient::DeleteVpcEndpoint, request, handler, context);
  }
 
  virtual Model::GetAccessPolicyOutcome GetAccessPolicy(const Model::GetAccessPolicyRequest& request) const;
 
  template <typename GetAccessPolicyRequestT = Model::GetAccessPolicyRequest>
  Model::GetAccessPolicyOutcomeCallable GetAccessPolicyCallable(const GetAccessPolicyRequestT& request) const {
    return SubmitCallable(&OpenSearchServerlessClient::GetAccessPolicy, request);
  }
 
  template <typename GetAccessPolicyRequestT = Model::GetAccessPolicyRequest>
  void GetAccessPolicyAsync(const GetAccessPolicyRequestT& request, const GetAccessPolicyResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServerlessClient::GetAccessPolicy, request, handler, context);
  }
 
  virtual Model::GetAccountSettingsOutcome GetAccountSettings(const Model::GetAccountSettingsRequest& request = {}) const;
 
  template <typename GetAccountSettingsRequestT = Model::GetAccountSettingsRequest>
  Model::GetAccountSettingsOutcomeCallable GetAccountSettingsCallable(const GetAccountSettingsRequestT& request = {}) const {
    return SubmitCallable(&OpenSearchServerlessClient::GetAccountSettings, request);
  }
 
  template <typename GetAccountSettingsRequestT = Model::GetAccountSettingsRequest>
  void GetAccountSettingsAsync(const GetAccountSettingsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const GetAccountSettingsRequestT& request = {}) const {
    return SubmitAsync(&OpenSearchServerlessClient::GetAccountSettings, request, handler, context);
  }
 
  virtual Model::GetIndexOutcome GetIndex(const Model::GetIndexRequest& request) const;
 
  template <typename GetIndexRequestT = Model::GetIndexRequest>
  Model::GetIndexOutcomeCallable GetIndexCallable(const GetIndexRequestT& request) const {
    return SubmitCallable(&OpenSearchServerlessClient::GetIndex, request);
  }
 
  template <typename GetIndexRequestT = Model::GetIndexRequest>
  void GetIndexAsync(const GetIndexRequestT& request, const GetIndexResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServerlessClient::GetIndex, request, handler, context);
  }
 
  virtual Model::GetPoliciesStatsOutcome GetPoliciesStats(const Model::GetPoliciesStatsRequest& request = {}) const;
 
  template <typename GetPoliciesStatsRequestT = Model::GetPoliciesStatsRequest>
  Model::GetPoliciesStatsOutcomeCallable GetPoliciesStatsCallable(const GetPoliciesStatsRequestT& request = {}) const {
    return SubmitCallable(&OpenSearchServerlessClient::GetPoliciesStats, request);
  }
 
  template <typename GetPoliciesStatsRequestT = Model::GetPoliciesStatsRequest>
  void GetPoliciesStatsAsync(const GetPoliciesStatsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const GetPoliciesStatsRequestT& request = {}) const {
    return SubmitAsync(&OpenSearchServerlessClient::GetPoliciesStats, request, handler, context);
  }
 
  virtual Model::GetSecurityConfigOutcome GetSecurityConfig(const Model::GetSecurityConfigRequest& request) const;
 
  template <typename GetSecurityConfigRequestT = Model::GetSecurityConfigRequest>
  Model::GetSecurityConfigOutcomeCallable GetSecurityConfigCallable(const GetSecurityConfigRequestT& request) const {
    return SubmitCallable(&OpenSearchServerlessClient::GetSecurityConfig, request);
  }
 
  template <typename GetSecurityConfigRequestT = Model::GetSecurityConfigRequest>
  void GetSecurityConfigAsync(const GetSecurityConfigRequestT& request, const GetSecurityConfigResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServerlessClient::GetSecurityConfig, request, handler, context);
  }
 
  virtual Model::GetSecurityPolicyOutcome GetSecurityPolicy(const Model::GetSecurityPolicyRequest& request) const;
 
  template <typename GetSecurityPolicyRequestT = Model::GetSecurityPolicyRequest>
  Model::GetSecurityPolicyOutcomeCallable GetSecurityPolicyCallable(const GetSecurityPolicyRequestT& request) const {
    return SubmitCallable(&OpenSearchServerlessClient::GetSecurityPolicy, request);
  }
 
  template <typename GetSecurityPolicyRequestT = Model::GetSecurityPolicyRequest>
  void GetSecurityPolicyAsync(const GetSecurityPolicyRequestT& request, const GetSecurityPolicyResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServerlessClient::GetSecurityPolicy, request, handler, context);
  }
 
  virtual Model::ListAccessPoliciesOutcome ListAccessPolicies(const Model::ListAccessPoliciesRequest& request) const;
 
  template <typename ListAccessPoliciesRequestT = Model::ListAccessPoliciesRequest>
  Model::ListAccessPoliciesOutcomeCallable ListAccessPoliciesCallable(const ListAccessPoliciesRequestT& request) const {
    return SubmitCallable(&OpenSearchServerlessClient::ListAccessPolicies, request);
  }
 
  template <typename ListAccessPoliciesRequestT = Model::ListAccessPoliciesRequest>
  void ListAccessPoliciesAsync(const ListAccessPoliciesRequestT& request, const ListAccessPoliciesResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServerlessClient::ListAccessPolicies, request, handler, context);
  }
 
  virtual Model::ListCollectionsOutcome ListCollections(const Model::ListCollectionsRequest& request = {}) const;
 
  template <typename ListCollectionsRequestT = Model::ListCollectionsRequest>
  Model::ListCollectionsOutcomeCallable ListCollectionsCallable(const ListCollectionsRequestT& request = {}) const {
    return SubmitCallable(&OpenSearchServerlessClient::ListCollections, request);
  }
 
  template <typename ListCollectionsRequestT = Model::ListCollectionsRequest>
  void ListCollectionsAsync(const ListCollectionsResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                            const ListCollectionsRequestT& request = {}) const {
    return SubmitAsync(&OpenSearchServerlessClient::ListCollections, request, handler, context);
  }
 
  virtual Model::ListLifecyclePoliciesOutcome ListLifecyclePolicies(const Model::ListLifecyclePoliciesRequest& request) const;
 
  template <typename ListLifecyclePoliciesRequestT = Model::ListLifecyclePoliciesRequest>
  Model::ListLifecyclePoliciesOutcomeCallable ListLifecyclePoliciesCallable(const ListLifecyclePoliciesRequestT& request) const {
    return SubmitCallable(&OpenSearchServerlessClient::ListLifecyclePolicies, request);
  }
 
  template <typename ListLifecyclePoliciesRequestT = Model::ListLifecyclePoliciesRequest>
  void ListLifecyclePoliciesAsync(const ListLifecyclePoliciesRequestT& request, const ListLifecyclePoliciesResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServerlessClient::ListLifecyclePolicies, request, handler, context);
  }
 
  virtual Model::ListSecurityConfigsOutcome ListSecurityConfigs(const Model::ListSecurityConfigsRequest& request) const;
 
  template <typename ListSecurityConfigsRequestT = Model::ListSecurityConfigsRequest>
  Model::ListSecurityConfigsOutcomeCallable ListSecurityConfigsCallable(const ListSecurityConfigsRequestT& request) const {
    return SubmitCallable(&OpenSearchServerlessClient::ListSecurityConfigs, request);
  }
 
  template <typename ListSecurityConfigsRequestT = Model::ListSecurityConfigsRequest>
  void ListSecurityConfigsAsync(const ListSecurityConfigsRequestT& request, const ListSecurityConfigsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServerlessClient::ListSecurityConfigs, request, handler, context);
  }
 
  virtual Model::ListSecurityPoliciesOutcome ListSecurityPolicies(const Model::ListSecurityPoliciesRequest& request) const;
 
  template <typename ListSecurityPoliciesRequestT = Model::ListSecurityPoliciesRequest>
  Model::ListSecurityPoliciesOutcomeCallable ListSecurityPoliciesCallable(const ListSecurityPoliciesRequestT& request) const {
    return SubmitCallable(&OpenSearchServerlessClient::ListSecurityPolicies, request);
  }
 
  template <typename ListSecurityPoliciesRequestT = Model::ListSecurityPoliciesRequest>
  void ListSecurityPoliciesAsync(const ListSecurityPoliciesRequestT& request, const ListSecurityPoliciesResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServerlessClient::ListSecurityPolicies, request, handler, context);
  }
 
  virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const;
 
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const {
    return SubmitCallable(&OpenSearchServerlessClient::ListTagsForResource, request);
  }
 
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServerlessClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::ListVpcEndpointsOutcome ListVpcEndpoints(const Model::ListVpcEndpointsRequest& request = {}) const;
 
  template <typename ListVpcEndpointsRequestT = Model::ListVpcEndpointsRequest>
  Model::ListVpcEndpointsOutcomeCallable ListVpcEndpointsCallable(const ListVpcEndpointsRequestT& request = {}) const {
    return SubmitCallable(&OpenSearchServerlessClient::ListVpcEndpoints, request);
  }
 
  template <typename ListVpcEndpointsRequestT = Model::ListVpcEndpointsRequest>
  void ListVpcEndpointsAsync(const ListVpcEndpointsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListVpcEndpointsRequestT& request = {}) const {
    return SubmitAsync(&OpenSearchServerlessClient::ListVpcEndpoints, request, handler, context);
  }
 
  virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const;
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const {
    return SubmitCallable(&OpenSearchServerlessClient::TagResource, request);
  }
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServerlessClient::TagResource, request, handler, context);
  }
 
  virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const {
    return SubmitCallable(&OpenSearchServerlessClient::UntagResource, request);
  }
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServerlessClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateAccessPolicyOutcome UpdateAccessPolicy(const Model::UpdateAccessPolicyRequest& request) const;
 
  template <typename UpdateAccessPolicyRequestT = Model::UpdateAccessPolicyRequest>
  Model::UpdateAccessPolicyOutcomeCallable UpdateAccessPolicyCallable(const UpdateAccessPolicyRequestT& request) const {
    return SubmitCallable(&OpenSearchServerlessClient::UpdateAccessPolicy, request);
  }
 
  template <typename UpdateAccessPolicyRequestT = Model::UpdateAccessPolicyRequest>
  void UpdateAccessPolicyAsync(const UpdateAccessPolicyRequestT& request, const UpdateAccessPolicyResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServerlessClient::UpdateAccessPolicy, request, handler, context);
  }
 
  virtual Model::UpdateAccountSettingsOutcome UpdateAccountSettings(const Model::UpdateAccountSettingsRequest& request = {}) const;
 
  template <typename UpdateAccountSettingsRequestT = Model::UpdateAccountSettingsRequest>
  Model::UpdateAccountSettingsOutcomeCallable UpdateAccountSettingsCallable(const UpdateAccountSettingsRequestT& request = {}) const {
    return SubmitCallable(&OpenSearchServerlessClient::UpdateAccountSettings, request);
  }
 
  template <typename UpdateAccountSettingsRequestT = Model::UpdateAccountSettingsRequest>
  void UpdateAccountSettingsAsync(const UpdateAccountSettingsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                  const UpdateAccountSettingsRequestT& request = {}) const {
    return SubmitAsync(&OpenSearchServerlessClient::UpdateAccountSettings, request, handler, context);
  }
 
  virtual Model::UpdateCollectionOutcome UpdateCollection(const Model::UpdateCollectionRequest& request) const;
 
  template <typename UpdateCollectionRequestT = Model::UpdateCollectionRequest>
  Model::UpdateCollectionOutcomeCallable UpdateCollectionCallable(const UpdateCollectionRequestT& request) const {
    return SubmitCallable(&OpenSearchServerlessClient::UpdateCollection, request);
  }
 
  template <typename UpdateCollectionRequestT = Model::UpdateCollectionRequest>
  void UpdateCollectionAsync(const UpdateCollectionRequestT& request, const UpdateCollectionResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServerlessClient::UpdateCollection, request, handler, context);
  }
 
  virtual Model::UpdateIndexOutcome UpdateIndex(const Model::UpdateIndexRequest& request) const;
 
  template <typename UpdateIndexRequestT = Model::UpdateIndexRequest>
  Model::UpdateIndexOutcomeCallable UpdateIndexCallable(const UpdateIndexRequestT& request) const {
    return SubmitCallable(&OpenSearchServerlessClient::UpdateIndex, request);
  }
 
  template <typename UpdateIndexRequestT = Model::UpdateIndexRequest>
  void UpdateIndexAsync(const UpdateIndexRequestT& request, const UpdateIndexResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServerlessClient::UpdateIndex, request, handler, context);
  }
 
  virtual Model::UpdateLifecyclePolicyOutcome UpdateLifecyclePolicy(const Model::UpdateLifecyclePolicyRequest& request) const;
 
  template <typename UpdateLifecyclePolicyRequestT = Model::UpdateLifecyclePolicyRequest>
  Model::UpdateLifecyclePolicyOutcomeCallable UpdateLifecyclePolicyCallable(const UpdateLifecyclePolicyRequestT& request) const {
    return SubmitCallable(&OpenSearchServerlessClient::UpdateLifecyclePolicy, request);
  }
 
  template <typename UpdateLifecyclePolicyRequestT = Model::UpdateLifecyclePolicyRequest>
  void UpdateLifecyclePolicyAsync(const UpdateLifecyclePolicyRequestT& request, const UpdateLifecyclePolicyResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServerlessClient::UpdateLifecyclePolicy, request, handler, context);
  }
 
  virtual Model::UpdateSecurityConfigOutcome UpdateSecurityConfig(const Model::UpdateSecurityConfigRequest& request) const;
 
  template <typename UpdateSecurityConfigRequestT = Model::UpdateSecurityConfigRequest>
  Model::UpdateSecurityConfigOutcomeCallable UpdateSecurityConfigCallable(const UpdateSecurityConfigRequestT& request) const {
    return SubmitCallable(&OpenSearchServerlessClient::UpdateSecurityConfig, request);
  }
 
  template <typename UpdateSecurityConfigRequestT = Model::UpdateSecurityConfigRequest>
  void UpdateSecurityConfigAsync(const UpdateSecurityConfigRequestT& request, const UpdateSecurityConfigResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServerlessClient::UpdateSecurityConfig, request, handler, context);
  }
 
  virtual Model::UpdateSecurityPolicyOutcome UpdateSecurityPolicy(const Model::UpdateSecurityPolicyRequest& request) const;
 
  template <typename UpdateSecurityPolicyRequestT = Model::UpdateSecurityPolicyRequest>
  Model::UpdateSecurityPolicyOutcomeCallable UpdateSecurityPolicyCallable(const UpdateSecurityPolicyRequestT& request) const {
    return SubmitCallable(&OpenSearchServerlessClient::UpdateSecurityPolicy, request);
  }
 
  template <typename UpdateSecurityPolicyRequestT = Model::UpdateSecurityPolicyRequest>
  void UpdateSecurityPolicyAsync(const UpdateSecurityPolicyRequestT& request, const UpdateSecurityPolicyResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServerlessClient::UpdateSecurityPolicy, request, handler, context);
  }
 
  virtual Model::UpdateVpcEndpointOutcome UpdateVpcEndpoint(const Model::UpdateVpcEndpointRequest& request) const;
 
  template <typename UpdateVpcEndpointRequestT = Model::UpdateVpcEndpointRequest>
  Model::UpdateVpcEndpointOutcomeCallable UpdateVpcEndpointCallable(const UpdateVpcEndpointRequestT& request) const {
    return SubmitCallable(&OpenSearchServerlessClient::UpdateVpcEndpoint, request);
  }
 
  template <typename UpdateVpcEndpointRequestT = Model::UpdateVpcEndpointRequest>
  void UpdateVpcEndpointAsync(const UpdateVpcEndpointRequestT& request, const UpdateVpcEndpointResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServerlessClient::UpdateVpcEndpoint, request, handler, context);
  }
 
  void OverrideEndpoint(const Aws::String& endpoint);
  std::shared_ptr<OpenSearchServerlessEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<OpenSearchServerlessClient>;
  void init(const OpenSearchServerlessClientConfiguration& clientConfiguration);
 
  OpenSearchServerlessClientConfiguration m_clientConfiguration;
  std::shared_ptr<OpenSearchServerlessEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace OpenSearchServerless
}  // namespace Aws