ResourceExplorer2Client.h

 
#pragma once
#include <aws/resource-explorer-2/ResourceExplorer2_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/resource-explorer-2/ResourceExplorer2ServiceClientModel.h>
 
namespace Aws
{
namespace ResourceExplorer2
{
  class AWS_RESOURCEEXPLORER2_API ResourceExplorer2Client : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<ResourceExplorer2Client>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef ResourceExplorer2ClientConfiguration ClientConfigurationType;
      typedef ResourceExplorer2EndpointProvider EndpointProviderType;
 
        ResourceExplorer2Client(const Aws::ResourceExplorer2::ResourceExplorer2ClientConfiguration& clientConfiguration = Aws::ResourceExplorer2::ResourceExplorer2ClientConfiguration(),
                                std::shared_ptr<ResourceExplorer2EndpointProviderBase> endpointProvider = nullptr);
 
        ResourceExplorer2Client(const Aws::Auth::AWSCredentials& credentials,
                                std::shared_ptr<ResourceExplorer2EndpointProviderBase> endpointProvider = nullptr,
                                const Aws::ResourceExplorer2::ResourceExplorer2ClientConfiguration& clientConfiguration = Aws::ResourceExplorer2::ResourceExplorer2ClientConfiguration());
 
        ResourceExplorer2Client(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                                std::shared_ptr<ResourceExplorer2EndpointProviderBase> endpointProvider = nullptr,
                                const Aws::ResourceExplorer2::ResourceExplorer2ClientConfiguration& clientConfiguration = Aws::ResourceExplorer2::ResourceExplorer2ClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        ResourceExplorer2Client(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        ResourceExplorer2Client(const Aws::Auth::AWSCredentials& credentials,
                                const Aws::Client::ClientConfiguration& clientConfiguration);
 
        ResourceExplorer2Client(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                                const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~ResourceExplorer2Client();
 
        virtual Model::AssociateDefaultViewOutcome AssociateDefaultView(const Model::AssociateDefaultViewRequest& request) const;
 
        template<typename AssociateDefaultViewRequestT = Model::AssociateDefaultViewRequest>
        Model::AssociateDefaultViewOutcomeCallable AssociateDefaultViewCallable(const AssociateDefaultViewRequestT& request) const
        {
            return SubmitCallable(&ResourceExplorer2Client::AssociateDefaultView, request);
        }
 
        template<typename AssociateDefaultViewRequestT = Model::AssociateDefaultViewRequest>
        void AssociateDefaultViewAsync(const AssociateDefaultViewRequestT& request, const AssociateDefaultViewResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ResourceExplorer2Client::AssociateDefaultView, request, handler, context);
        }
 
        virtual Model::BatchGetViewOutcome BatchGetView(const Model::BatchGetViewRequest& request = {}) const;
 
        template<typename BatchGetViewRequestT = Model::BatchGetViewRequest>
        Model::BatchGetViewOutcomeCallable BatchGetViewCallable(const BatchGetViewRequestT& request = {}) const
        {
            return SubmitCallable(&ResourceExplorer2Client::BatchGetView, request);
        }
 
        template<typename BatchGetViewRequestT = Model::BatchGetViewRequest>
        void BatchGetViewAsync(const BatchGetViewResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const BatchGetViewRequestT& request = {}) const
        {
            return SubmitAsync(&ResourceExplorer2Client::BatchGetView, 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(&ResourceExplorer2Client::CreateIndex, request);
        }
 
        template<typename CreateIndexRequestT = Model::CreateIndexRequest>
        void CreateIndexAsync(const CreateIndexResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const CreateIndexRequestT& request = {}) const
        {
            return SubmitAsync(&ResourceExplorer2Client::CreateIndex, request, handler, context);
        }
 
        virtual Model::CreateViewOutcome CreateView(const Model::CreateViewRequest& request) const;
 
        template<typename CreateViewRequestT = Model::CreateViewRequest>
        Model::CreateViewOutcomeCallable CreateViewCallable(const CreateViewRequestT& request) const
        {
            return SubmitCallable(&ResourceExplorer2Client::CreateView, request);
        }
 
        template<typename CreateViewRequestT = Model::CreateViewRequest>
        void CreateViewAsync(const CreateViewRequestT& request, const CreateViewResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ResourceExplorer2Client::CreateView, 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(&ResourceExplorer2Client::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(&ResourceExplorer2Client::DeleteIndex, request, handler, context);
        }
 
        virtual Model::DeleteViewOutcome DeleteView(const Model::DeleteViewRequest& request) const;
 
        template<typename DeleteViewRequestT = Model::DeleteViewRequest>
        Model::DeleteViewOutcomeCallable DeleteViewCallable(const DeleteViewRequestT& request) const
        {
            return SubmitCallable(&ResourceExplorer2Client::DeleteView, request);
        }
 
        template<typename DeleteViewRequestT = Model::DeleteViewRequest>
        void DeleteViewAsync(const DeleteViewRequestT& request, const DeleteViewResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ResourceExplorer2Client::DeleteView, request, handler, context);
        }
 
        virtual Model::DisassociateDefaultViewOutcome DisassociateDefaultView(const Model::DisassociateDefaultViewRequest& request = {}) const;
 
        template<typename DisassociateDefaultViewRequestT = Model::DisassociateDefaultViewRequest>
        Model::DisassociateDefaultViewOutcomeCallable DisassociateDefaultViewCallable(const DisassociateDefaultViewRequestT& request = {}) const
        {
            return SubmitCallable(&ResourceExplorer2Client::DisassociateDefaultView, request);
        }
 
        template<typename DisassociateDefaultViewRequestT = Model::DisassociateDefaultViewRequest>
        void DisassociateDefaultViewAsync(const DisassociateDefaultViewResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DisassociateDefaultViewRequestT& request = {}) const
        {
            return SubmitAsync(&ResourceExplorer2Client::DisassociateDefaultView, request, handler, context);
        }
 
        virtual Model::GetAccountLevelServiceConfigurationOutcome GetAccountLevelServiceConfiguration(const Model::GetAccountLevelServiceConfigurationRequest& request = {}) const;
 
        template<typename GetAccountLevelServiceConfigurationRequestT = Model::GetAccountLevelServiceConfigurationRequest>
        Model::GetAccountLevelServiceConfigurationOutcomeCallable GetAccountLevelServiceConfigurationCallable(const GetAccountLevelServiceConfigurationRequestT& request = {}) const
        {
            return SubmitCallable(&ResourceExplorer2Client::GetAccountLevelServiceConfiguration, request);
        }
 
        template<typename GetAccountLevelServiceConfigurationRequestT = Model::GetAccountLevelServiceConfigurationRequest>
        void GetAccountLevelServiceConfigurationAsync(const GetAccountLevelServiceConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetAccountLevelServiceConfigurationRequestT& request = {}) const
        {
            return SubmitAsync(&ResourceExplorer2Client::GetAccountLevelServiceConfiguration, request, handler, context);
        }
 
        virtual Model::GetDefaultViewOutcome GetDefaultView(const Model::GetDefaultViewRequest& request = {}) const;
 
        template<typename GetDefaultViewRequestT = Model::GetDefaultViewRequest>
        Model::GetDefaultViewOutcomeCallable GetDefaultViewCallable(const GetDefaultViewRequestT& request = {}) const
        {
            return SubmitCallable(&ResourceExplorer2Client::GetDefaultView, request);
        }
 
        template<typename GetDefaultViewRequestT = Model::GetDefaultViewRequest>
        void GetDefaultViewAsync(const GetDefaultViewResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetDefaultViewRequestT& request = {}) const
        {
            return SubmitAsync(&ResourceExplorer2Client::GetDefaultView, 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(&ResourceExplorer2Client::GetIndex, request);
        }
 
        template<typename GetIndexRequestT = Model::GetIndexRequest>
        void GetIndexAsync(const GetIndexResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetIndexRequestT& request = {}) const
        {
            return SubmitAsync(&ResourceExplorer2Client::GetIndex, request, handler, context);
        }
 
        virtual Model::GetViewOutcome GetView(const Model::GetViewRequest& request) const;
 
        template<typename GetViewRequestT = Model::GetViewRequest>
        Model::GetViewOutcomeCallable GetViewCallable(const GetViewRequestT& request) const
        {
            return SubmitCallable(&ResourceExplorer2Client::GetView, request);
        }
 
        template<typename GetViewRequestT = Model::GetViewRequest>
        void GetViewAsync(const GetViewRequestT& request, const GetViewResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ResourceExplorer2Client::GetView, request, handler, context);
        }
 
        virtual Model::ListIndexesOutcome ListIndexes(const Model::ListIndexesRequest& request = {}) const;
 
        template<typename ListIndexesRequestT = Model::ListIndexesRequest>
        Model::ListIndexesOutcomeCallable ListIndexesCallable(const ListIndexesRequestT& request = {}) const
        {
            return SubmitCallable(&ResourceExplorer2Client::ListIndexes, request);
        }
 
        template<typename ListIndexesRequestT = Model::ListIndexesRequest>
        void ListIndexesAsync(const ListIndexesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListIndexesRequestT& request = {}) const
        {
            return SubmitAsync(&ResourceExplorer2Client::ListIndexes, request, handler, context);
        }
 
        virtual Model::ListIndexesForMembersOutcome ListIndexesForMembers(const Model::ListIndexesForMembersRequest& request) const;
 
        template<typename ListIndexesForMembersRequestT = Model::ListIndexesForMembersRequest>
        Model::ListIndexesForMembersOutcomeCallable ListIndexesForMembersCallable(const ListIndexesForMembersRequestT& request) const
        {
            return SubmitCallable(&ResourceExplorer2Client::ListIndexesForMembers, request);
        }
 
        template<typename ListIndexesForMembersRequestT = Model::ListIndexesForMembersRequest>
        void ListIndexesForMembersAsync(const ListIndexesForMembersRequestT& request, const ListIndexesForMembersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ResourceExplorer2Client::ListIndexesForMembers, request, handler, context);
        }
 
        virtual Model::ListResourcesOutcome ListResources(const Model::ListResourcesRequest& request = {}) const;
 
        template<typename ListResourcesRequestT = Model::ListResourcesRequest>
        Model::ListResourcesOutcomeCallable ListResourcesCallable(const ListResourcesRequestT& request = {}) const
        {
            return SubmitCallable(&ResourceExplorer2Client::ListResources, request);
        }
 
        template<typename ListResourcesRequestT = Model::ListResourcesRequest>
        void ListResourcesAsync(const ListResourcesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListResourcesRequestT& request = {}) const
        {
            return SubmitAsync(&ResourceExplorer2Client::ListResources, request, handler, context);
        }
 
        virtual Model::ListSupportedResourceTypesOutcome ListSupportedResourceTypes(const Model::ListSupportedResourceTypesRequest& request = {}) const;
 
        template<typename ListSupportedResourceTypesRequestT = Model::ListSupportedResourceTypesRequest>
        Model::ListSupportedResourceTypesOutcomeCallable ListSupportedResourceTypesCallable(const ListSupportedResourceTypesRequestT& request = {}) const
        {
            return SubmitCallable(&ResourceExplorer2Client::ListSupportedResourceTypes, request);
        }
 
        template<typename ListSupportedResourceTypesRequestT = Model::ListSupportedResourceTypesRequest>
        void ListSupportedResourceTypesAsync(const ListSupportedResourceTypesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListSupportedResourceTypesRequestT& request = {}) const
        {
            return SubmitAsync(&ResourceExplorer2Client::ListSupportedResourceTypes, 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(&ResourceExplorer2Client::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(&ResourceExplorer2Client::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::ListViewsOutcome ListViews(const Model::ListViewsRequest& request = {}) const;
 
        template<typename ListViewsRequestT = Model::ListViewsRequest>
        Model::ListViewsOutcomeCallable ListViewsCallable(const ListViewsRequestT& request = {}) const
        {
            return SubmitCallable(&ResourceExplorer2Client::ListViews, request);
        }
 
        template<typename ListViewsRequestT = Model::ListViewsRequest>
        void ListViewsAsync(const ListViewsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListViewsRequestT& request = {}) const
        {
            return SubmitAsync(&ResourceExplorer2Client::ListViews, request, handler, context);
        }
 
        virtual Model::SearchOutcome Search(const Model::SearchRequest& request) const;
 
        template<typename SearchRequestT = Model::SearchRequest>
        Model::SearchOutcomeCallable SearchCallable(const SearchRequestT& request) const
        {
            return SubmitCallable(&ResourceExplorer2Client::Search, request);
        }
 
        template<typename SearchRequestT = Model::SearchRequest>
        void SearchAsync(const SearchRequestT& request, const SearchResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ResourceExplorer2Client::Search, 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(&ResourceExplorer2Client::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(&ResourceExplorer2Client::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(&ResourceExplorer2Client::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(&ResourceExplorer2Client::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateIndexTypeOutcome UpdateIndexType(const Model::UpdateIndexTypeRequest& request) const;
 
        template<typename UpdateIndexTypeRequestT = Model::UpdateIndexTypeRequest>
        Model::UpdateIndexTypeOutcomeCallable UpdateIndexTypeCallable(const UpdateIndexTypeRequestT& request) const
        {
            return SubmitCallable(&ResourceExplorer2Client::UpdateIndexType, request);
        }
 
        template<typename UpdateIndexTypeRequestT = Model::UpdateIndexTypeRequest>
        void UpdateIndexTypeAsync(const UpdateIndexTypeRequestT& request, const UpdateIndexTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ResourceExplorer2Client::UpdateIndexType, request, handler, context);
        }
 
        virtual Model::UpdateViewOutcome UpdateView(const Model::UpdateViewRequest& request) const;
 
        template<typename UpdateViewRequestT = Model::UpdateViewRequest>
        Model::UpdateViewOutcomeCallable UpdateViewCallable(const UpdateViewRequestT& request) const
        {
            return SubmitCallable(&ResourceExplorer2Client::UpdateView, request);
        }
 
        template<typename UpdateViewRequestT = Model::UpdateViewRequest>
        void UpdateViewAsync(const UpdateViewRequestT& request, const UpdateViewResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ResourceExplorer2Client::UpdateView, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<ResourceExplorer2EndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<ResourceExplorer2Client>;
      void init(const ResourceExplorer2ClientConfiguration& clientConfiguration);
 
      ResourceExplorer2ClientConfiguration m_clientConfiguration;
      std::shared_ptr<ResourceExplorer2EndpointProviderBase> m_endpointProvider;
  };
 
} // namespace ResourceExplorer2
} // namespace Aws