ResourceGroupsClient.h

 
#pragma once
#include <aws/resource-groups/ResourceGroups_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-groups/ResourceGroupsServiceClientModel.h>
 
namespace Aws
{
namespace ResourceGroups
{
  class AWS_RESOURCEGROUPS_API ResourceGroupsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<ResourceGroupsClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef ResourceGroupsClientConfiguration ClientConfigurationType;
      typedef ResourceGroupsEndpointProvider EndpointProviderType;
 
        ResourceGroupsClient(const Aws::ResourceGroups::ResourceGroupsClientConfiguration& clientConfiguration = Aws::ResourceGroups::ResourceGroupsClientConfiguration(),
                             std::shared_ptr<ResourceGroupsEndpointProviderBase> endpointProvider = nullptr);
 
        ResourceGroupsClient(const Aws::Auth::AWSCredentials& credentials,
                             std::shared_ptr<ResourceGroupsEndpointProviderBase> endpointProvider = nullptr,
                             const Aws::ResourceGroups::ResourceGroupsClientConfiguration& clientConfiguration = Aws::ResourceGroups::ResourceGroupsClientConfiguration());
 
        ResourceGroupsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                             std::shared_ptr<ResourceGroupsEndpointProviderBase> endpointProvider = nullptr,
                             const Aws::ResourceGroups::ResourceGroupsClientConfiguration& clientConfiguration = Aws::ResourceGroups::ResourceGroupsClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        ResourceGroupsClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        ResourceGroupsClient(const Aws::Auth::AWSCredentials& credentials,
                             const Aws::Client::ClientConfiguration& clientConfiguration);
 
        ResourceGroupsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                             const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~ResourceGroupsClient();
 
        virtual Model::CancelTagSyncTaskOutcome CancelTagSyncTask(const Model::CancelTagSyncTaskRequest& request) const;
 
        template<typename CancelTagSyncTaskRequestT = Model::CancelTagSyncTaskRequest>
        Model::CancelTagSyncTaskOutcomeCallable CancelTagSyncTaskCallable(const CancelTagSyncTaskRequestT& request) const
        {
            return SubmitCallable(&ResourceGroupsClient::CancelTagSyncTask, request);
        }
 
        template<typename CancelTagSyncTaskRequestT = Model::CancelTagSyncTaskRequest>
        void CancelTagSyncTaskAsync(const CancelTagSyncTaskRequestT& request, const CancelTagSyncTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ResourceGroupsClient::CancelTagSyncTask, request, handler, context);
        }
 
        virtual Model::CreateGroupOutcome CreateGroup(const Model::CreateGroupRequest& request) const;
 
        template<typename CreateGroupRequestT = Model::CreateGroupRequest>
        Model::CreateGroupOutcomeCallable CreateGroupCallable(const CreateGroupRequestT& request) const
        {
            return SubmitCallable(&ResourceGroupsClient::CreateGroup, request);
        }
 
        template<typename CreateGroupRequestT = Model::CreateGroupRequest>
        void CreateGroupAsync(const CreateGroupRequestT& request, const CreateGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ResourceGroupsClient::CreateGroup, request, handler, context);
        }
 
        virtual Model::DeleteGroupOutcome DeleteGroup(const Model::DeleteGroupRequest& request = {}) const;
 
        template<typename DeleteGroupRequestT = Model::DeleteGroupRequest>
        Model::DeleteGroupOutcomeCallable DeleteGroupCallable(const DeleteGroupRequestT& request = {}) const
        {
            return SubmitCallable(&ResourceGroupsClient::DeleteGroup, request);
        }
 
        template<typename DeleteGroupRequestT = Model::DeleteGroupRequest>
        void DeleteGroupAsync(const DeleteGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DeleteGroupRequestT& request = {}) const
        {
            return SubmitAsync(&ResourceGroupsClient::DeleteGroup, 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(&ResourceGroupsClient::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(&ResourceGroupsClient::GetAccountSettings, request, handler, context);
        }
 
        virtual Model::GetGroupOutcome GetGroup(const Model::GetGroupRequest& request = {}) const;
 
        template<typename GetGroupRequestT = Model::GetGroupRequest>
        Model::GetGroupOutcomeCallable GetGroupCallable(const GetGroupRequestT& request = {}) const
        {
            return SubmitCallable(&ResourceGroupsClient::GetGroup, request);
        }
 
        template<typename GetGroupRequestT = Model::GetGroupRequest>
        void GetGroupAsync(const GetGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetGroupRequestT& request = {}) const
        {
            return SubmitAsync(&ResourceGroupsClient::GetGroup, request, handler, context);
        }
 
        virtual Model::GetGroupConfigurationOutcome GetGroupConfiguration(const Model::GetGroupConfigurationRequest& request = {}) const;
 
        template<typename GetGroupConfigurationRequestT = Model::GetGroupConfigurationRequest>
        Model::GetGroupConfigurationOutcomeCallable GetGroupConfigurationCallable(const GetGroupConfigurationRequestT& request = {}) const
        {
            return SubmitCallable(&ResourceGroupsClient::GetGroupConfiguration, request);
        }
 
        template<typename GetGroupConfigurationRequestT = Model::GetGroupConfigurationRequest>
        void GetGroupConfigurationAsync(const GetGroupConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetGroupConfigurationRequestT& request = {}) const
        {
            return SubmitAsync(&ResourceGroupsClient::GetGroupConfiguration, request, handler, context);
        }
 
        virtual Model::GetGroupQueryOutcome GetGroupQuery(const Model::GetGroupQueryRequest& request = {}) const;
 
        template<typename GetGroupQueryRequestT = Model::GetGroupQueryRequest>
        Model::GetGroupQueryOutcomeCallable GetGroupQueryCallable(const GetGroupQueryRequestT& request = {}) const
        {
            return SubmitCallable(&ResourceGroupsClient::GetGroupQuery, request);
        }
 
        template<typename GetGroupQueryRequestT = Model::GetGroupQueryRequest>
        void GetGroupQueryAsync(const GetGroupQueryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetGroupQueryRequestT& request = {}) const
        {
            return SubmitAsync(&ResourceGroupsClient::GetGroupQuery, request, handler, context);
        }
 
        virtual Model::GetTagSyncTaskOutcome GetTagSyncTask(const Model::GetTagSyncTaskRequest& request) const;
 
        template<typename GetTagSyncTaskRequestT = Model::GetTagSyncTaskRequest>
        Model::GetTagSyncTaskOutcomeCallable GetTagSyncTaskCallable(const GetTagSyncTaskRequestT& request) const
        {
            return SubmitCallable(&ResourceGroupsClient::GetTagSyncTask, request);
        }
 
        template<typename GetTagSyncTaskRequestT = Model::GetTagSyncTaskRequest>
        void GetTagSyncTaskAsync(const GetTagSyncTaskRequestT& request, const GetTagSyncTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ResourceGroupsClient::GetTagSyncTask, request, handler, context);
        }
 
        virtual Model::GetTagsOutcome GetTags(const Model::GetTagsRequest& request) const;
 
        template<typename GetTagsRequestT = Model::GetTagsRequest>
        Model::GetTagsOutcomeCallable GetTagsCallable(const GetTagsRequestT& request) const
        {
            return SubmitCallable(&ResourceGroupsClient::GetTags, request);
        }
 
        template<typename GetTagsRequestT = Model::GetTagsRequest>
        void GetTagsAsync(const GetTagsRequestT& request, const GetTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ResourceGroupsClient::GetTags, request, handler, context);
        }
 
        virtual Model::GroupResourcesOutcome GroupResources(const Model::GroupResourcesRequest& request) const;
 
        template<typename GroupResourcesRequestT = Model::GroupResourcesRequest>
        Model::GroupResourcesOutcomeCallable GroupResourcesCallable(const GroupResourcesRequestT& request) const
        {
            return SubmitCallable(&ResourceGroupsClient::GroupResources, request);
        }
 
        template<typename GroupResourcesRequestT = Model::GroupResourcesRequest>
        void GroupResourcesAsync(const GroupResourcesRequestT& request, const GroupResourcesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ResourceGroupsClient::GroupResources, request, handler, context);
        }
 
        virtual Model::ListGroupResourcesOutcome ListGroupResources(const Model::ListGroupResourcesRequest& request = {}) const;
 
        template<typename ListGroupResourcesRequestT = Model::ListGroupResourcesRequest>
        Model::ListGroupResourcesOutcomeCallable ListGroupResourcesCallable(const ListGroupResourcesRequestT& request = {}) const
        {
            return SubmitCallable(&ResourceGroupsClient::ListGroupResources, request);
        }
 
        template<typename ListGroupResourcesRequestT = Model::ListGroupResourcesRequest>
        void ListGroupResourcesAsync(const ListGroupResourcesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListGroupResourcesRequestT& request = {}) const
        {
            return SubmitAsync(&ResourceGroupsClient::ListGroupResources, request, handler, context);
        }
 
        virtual Model::ListGroupingStatusesOutcome ListGroupingStatuses(const Model::ListGroupingStatusesRequest& request) const;
 
        template<typename ListGroupingStatusesRequestT = Model::ListGroupingStatusesRequest>
        Model::ListGroupingStatusesOutcomeCallable ListGroupingStatusesCallable(const ListGroupingStatusesRequestT& request) const
        {
            return SubmitCallable(&ResourceGroupsClient::ListGroupingStatuses, request);
        }
 
        template<typename ListGroupingStatusesRequestT = Model::ListGroupingStatusesRequest>
        void ListGroupingStatusesAsync(const ListGroupingStatusesRequestT& request, const ListGroupingStatusesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ResourceGroupsClient::ListGroupingStatuses, request, handler, context);
        }
 
        virtual Model::ListGroupsOutcome ListGroups(const Model::ListGroupsRequest& request = {}) const;
 
        template<typename ListGroupsRequestT = Model::ListGroupsRequest>
        Model::ListGroupsOutcomeCallable ListGroupsCallable(const ListGroupsRequestT& request = {}) const
        {
            return SubmitCallable(&ResourceGroupsClient::ListGroups, request);
        }
 
        template<typename ListGroupsRequestT = Model::ListGroupsRequest>
        void ListGroupsAsync(const ListGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListGroupsRequestT& request = {}) const
        {
            return SubmitAsync(&ResourceGroupsClient::ListGroups, request, handler, context);
        }
 
        virtual Model::ListTagSyncTasksOutcome ListTagSyncTasks(const Model::ListTagSyncTasksRequest& request = {}) const;
 
        template<typename ListTagSyncTasksRequestT = Model::ListTagSyncTasksRequest>
        Model::ListTagSyncTasksOutcomeCallable ListTagSyncTasksCallable(const ListTagSyncTasksRequestT& request = {}) const
        {
            return SubmitCallable(&ResourceGroupsClient::ListTagSyncTasks, request);
        }
 
        template<typename ListTagSyncTasksRequestT = Model::ListTagSyncTasksRequest>
        void ListTagSyncTasksAsync(const ListTagSyncTasksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListTagSyncTasksRequestT& request = {}) const
        {
            return SubmitAsync(&ResourceGroupsClient::ListTagSyncTasks, request, handler, context);
        }
 
        virtual Model::PutGroupConfigurationOutcome PutGroupConfiguration(const Model::PutGroupConfigurationRequest& request = {}) const;
 
        template<typename PutGroupConfigurationRequestT = Model::PutGroupConfigurationRequest>
        Model::PutGroupConfigurationOutcomeCallable PutGroupConfigurationCallable(const PutGroupConfigurationRequestT& request = {}) const
        {
            return SubmitCallable(&ResourceGroupsClient::PutGroupConfiguration, request);
        }
 
        template<typename PutGroupConfigurationRequestT = Model::PutGroupConfigurationRequest>
        void PutGroupConfigurationAsync(const PutGroupConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const PutGroupConfigurationRequestT& request = {}) const
        {
            return SubmitAsync(&ResourceGroupsClient::PutGroupConfiguration, request, handler, context);
        }
 
        virtual Model::SearchResourcesOutcome SearchResources(const Model::SearchResourcesRequest& request) const;
 
        template<typename SearchResourcesRequestT = Model::SearchResourcesRequest>
        Model::SearchResourcesOutcomeCallable SearchResourcesCallable(const SearchResourcesRequestT& request) const
        {
            return SubmitCallable(&ResourceGroupsClient::SearchResources, request);
        }
 
        template<typename SearchResourcesRequestT = Model::SearchResourcesRequest>
        void SearchResourcesAsync(const SearchResourcesRequestT& request, const SearchResourcesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ResourceGroupsClient::SearchResources, request, handler, context);
        }
 
        virtual Model::StartTagSyncTaskOutcome StartTagSyncTask(const Model::StartTagSyncTaskRequest& request) const;
 
        template<typename StartTagSyncTaskRequestT = Model::StartTagSyncTaskRequest>
        Model::StartTagSyncTaskOutcomeCallable StartTagSyncTaskCallable(const StartTagSyncTaskRequestT& request) const
        {
            return SubmitCallable(&ResourceGroupsClient::StartTagSyncTask, request);
        }
 
        template<typename StartTagSyncTaskRequestT = Model::StartTagSyncTaskRequest>
        void StartTagSyncTaskAsync(const StartTagSyncTaskRequestT& request, const StartTagSyncTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ResourceGroupsClient::StartTagSyncTask, request, handler, context);
        }
 
        virtual Model::TagOutcome Tag(const Model::TagRequest& request) const;
 
        template<typename TagRequestT = Model::TagRequest>
        Model::TagOutcomeCallable TagCallable(const TagRequestT& request) const
        {
            return SubmitCallable(&ResourceGroupsClient::Tag, request);
        }
 
        template<typename TagRequestT = Model::TagRequest>
        void TagAsync(const TagRequestT& request, const TagResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ResourceGroupsClient::Tag, request, handler, context);
        }
 
        virtual Model::UngroupResourcesOutcome UngroupResources(const Model::UngroupResourcesRequest& request) const;
 
        template<typename UngroupResourcesRequestT = Model::UngroupResourcesRequest>
        Model::UngroupResourcesOutcomeCallable UngroupResourcesCallable(const UngroupResourcesRequestT& request) const
        {
            return SubmitCallable(&ResourceGroupsClient::UngroupResources, request);
        }
 
        template<typename UngroupResourcesRequestT = Model::UngroupResourcesRequest>
        void UngroupResourcesAsync(const UngroupResourcesRequestT& request, const UngroupResourcesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ResourceGroupsClient::UngroupResources, request, handler, context);
        }
 
        virtual Model::UntagOutcome Untag(const Model::UntagRequest& request) const;
 
        template<typename UntagRequestT = Model::UntagRequest>
        Model::UntagOutcomeCallable UntagCallable(const UntagRequestT& request) const
        {
            return SubmitCallable(&ResourceGroupsClient::Untag, request);
        }
 
        template<typename UntagRequestT = Model::UntagRequest>
        void UntagAsync(const UntagRequestT& request, const UntagResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ResourceGroupsClient::Untag, 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(&ResourceGroupsClient::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(&ResourceGroupsClient::UpdateAccountSettings, request, handler, context);
        }
 
        virtual Model::UpdateGroupOutcome UpdateGroup(const Model::UpdateGroupRequest& request = {}) const;
 
        template<typename UpdateGroupRequestT = Model::UpdateGroupRequest>
        Model::UpdateGroupOutcomeCallable UpdateGroupCallable(const UpdateGroupRequestT& request = {}) const
        {
            return SubmitCallable(&ResourceGroupsClient::UpdateGroup, request);
        }
 
        template<typename UpdateGroupRequestT = Model::UpdateGroupRequest>
        void UpdateGroupAsync(const UpdateGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const UpdateGroupRequestT& request = {}) const
        {
            return SubmitAsync(&ResourceGroupsClient::UpdateGroup, request, handler, context);
        }
 
        virtual Model::UpdateGroupQueryOutcome UpdateGroupQuery(const Model::UpdateGroupQueryRequest& request) const;
 
        template<typename UpdateGroupQueryRequestT = Model::UpdateGroupQueryRequest>
        Model::UpdateGroupQueryOutcomeCallable UpdateGroupQueryCallable(const UpdateGroupQueryRequestT& request) const
        {
            return SubmitCallable(&ResourceGroupsClient::UpdateGroupQuery, request);
        }
 
        template<typename UpdateGroupQueryRequestT = Model::UpdateGroupQueryRequest>
        void UpdateGroupQueryAsync(const UpdateGroupQueryRequestT& request, const UpdateGroupQueryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ResourceGroupsClient::UpdateGroupQuery, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<ResourceGroupsEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<ResourceGroupsClient>;
      void init(const ResourceGroupsClientConfiguration& clientConfiguration);
 
      ResourceGroupsClientConfiguration m_clientConfiguration;
      std::shared_ptr<ResourceGroupsEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace ResourceGroups
} // namespace Aws