ResourceGroupsClient.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/resource-groups/ResourceGroupsPaginationBase.h>
#include <aws/resource-groups/ResourceGroupsServiceClientModel.h>
#include <aws/resource-groups/ResourceGroupsWaiter.h>
#include <aws/resource-groups/ResourceGroups_EXPORTS.h>
 
namespace Aws {
namespace ResourceGroups {
class AWS_RESOURCEGROUPS_API ResourceGroupsClient : public Aws::Client::AWSJsonClient,
                                                    public Aws::Client::ClientWithAsyncTemplateMethods<ResourceGroupsClient>,
                                                    public ResourceGroupsPaginationBase<ResourceGroupsClient>,
                                                    public ResourceGroupsWaiter<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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<ResourceGroupsEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<ResourceGroupsClient>;
  void init(const ResourceGroupsClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, ResourceGroupsError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  ResourceGroupsClientConfiguration m_clientConfiguration;
  std::shared_ptr<ResourceGroupsEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace ResourceGroups
}  // namespace Aws