OpenSearchServerlessClient.h

 
#pragma once
#include <aws/opensearchserverless/OpenSearchServerless_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/opensearchserverless/OpenSearchServerlessServiceClientModel.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