AgentRegistryControlClient.h

 
#pragma once
#include <aws/agent-registry-control/AgentRegistryControlPaginationBase.h>
#include <aws/agent-registry-control/AgentRegistryControlServiceClientModel.h>
#include <aws/agent-registry-control/AgentRegistryControlWaiter.h>
#include <aws/agent-registry-control/AgentRegistryControl_EXPORTS.h>
#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>
 
namespace Aws {
namespace AgentRegistryControl {
class AWS_AGENTREGISTRYCONTROL_API AgentRegistryControlClient
    : public Aws::Client::AWSJsonClient,
      public Aws::Client::ClientWithAsyncTemplateMethods<AgentRegistryControlClient>,
      public AgentRegistryControlPaginationBase<AgentRegistryControlClient>,
      public AgentRegistryControlWaiter<AgentRegistryControlClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef AgentRegistryControlClientConfiguration ClientConfigurationType;
  typedef AgentRegistryControlEndpointProvider EndpointProviderType;
 
  AgentRegistryControlClient(const Aws::AgentRegistryControl::AgentRegistryControlClientConfiguration& clientConfiguration =
                                 Aws::AgentRegistryControl::AgentRegistryControlClientConfiguration(),
                             std::shared_ptr<AgentRegistryControlEndpointProviderBase> endpointProvider = nullptr);
 
  AgentRegistryControlClient(const Aws::Auth::AWSCredentials& credentials,
                             std::shared_ptr<AgentRegistryControlEndpointProviderBase> endpointProvider = nullptr,
                             const Aws::AgentRegistryControl::AgentRegistryControlClientConfiguration& clientConfiguration =
                                 Aws::AgentRegistryControl::AgentRegistryControlClientConfiguration());
 
  AgentRegistryControlClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                             std::shared_ptr<AgentRegistryControlEndpointProviderBase> endpointProvider = nullptr,
                             const Aws::AgentRegistryControl::AgentRegistryControlClientConfiguration& clientConfiguration =
                                 Aws::AgentRegistryControl::AgentRegistryControlClientConfiguration());
 
  /* Legacy constructors due deprecation */
  AgentRegistryControlClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  AgentRegistryControlClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  AgentRegistryControlClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                             const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~AgentRegistryControlClient();
 
  virtual Model::CreateRegistryOutcome CreateRegistry(const Model::CreateRegistryRequest& request) const;
 
  template <typename CreateRegistryRequestT = Model::CreateRegistryRequest>
  Model::CreateRegistryOutcomeCallable CreateRegistryCallable(const CreateRegistryRequestT& request) const {
    return SubmitCallable(&AgentRegistryControlClient::CreateRegistry, request);
  }
 
  template <typename CreateRegistryRequestT = Model::CreateRegistryRequest>
  void CreateRegistryAsync(const CreateRegistryRequestT& request, const CreateRegistryResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AgentRegistryControlClient::CreateRegistry, request, handler, context);
  }
 
  virtual Model::CreateRegistryRecordOutcome CreateRegistryRecord(const Model::CreateRegistryRecordRequest& request) const;
 
  template <typename CreateRegistryRecordRequestT = Model::CreateRegistryRecordRequest>
  Model::CreateRegistryRecordOutcomeCallable CreateRegistryRecordCallable(const CreateRegistryRecordRequestT& request) const {
    return SubmitCallable(&AgentRegistryControlClient::CreateRegistryRecord, request);
  }
 
  template <typename CreateRegistryRecordRequestT = Model::CreateRegistryRecordRequest>
  void CreateRegistryRecordAsync(const CreateRegistryRecordRequestT& request, const CreateRegistryRecordResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AgentRegistryControlClient::CreateRegistryRecord, request, handler, context);
  }
 
  virtual Model::DeleteRegistryOutcome DeleteRegistry(const Model::DeleteRegistryRequest& request) const;
 
  template <typename DeleteRegistryRequestT = Model::DeleteRegistryRequest>
  Model::DeleteRegistryOutcomeCallable DeleteRegistryCallable(const DeleteRegistryRequestT& request) const {
    return SubmitCallable(&AgentRegistryControlClient::DeleteRegistry, request);
  }
 
  template <typename DeleteRegistryRequestT = Model::DeleteRegistryRequest>
  void DeleteRegistryAsync(const DeleteRegistryRequestT& request, const DeleteRegistryResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AgentRegistryControlClient::DeleteRegistry, request, handler, context);
  }
 
  virtual Model::DeleteRegistryRecordOutcome DeleteRegistryRecord(const Model::DeleteRegistryRecordRequest& request) const;
 
  template <typename DeleteRegistryRecordRequestT = Model::DeleteRegistryRecordRequest>
  Model::DeleteRegistryRecordOutcomeCallable DeleteRegistryRecordCallable(const DeleteRegistryRecordRequestT& request) const {
    return SubmitCallable(&AgentRegistryControlClient::DeleteRegistryRecord, request);
  }
 
  template <typename DeleteRegistryRecordRequestT = Model::DeleteRegistryRecordRequest>
  void DeleteRegistryRecordAsync(const DeleteRegistryRecordRequestT& request, const DeleteRegistryRecordResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AgentRegistryControlClient::DeleteRegistryRecord, request, handler, context);
  }
 
  virtual Model::GetRegistryOutcome GetRegistry(const Model::GetRegistryRequest& request) const;
 
  template <typename GetRegistryRequestT = Model::GetRegistryRequest>
  Model::GetRegistryOutcomeCallable GetRegistryCallable(const GetRegistryRequestT& request) const {
    return SubmitCallable(&AgentRegistryControlClient::GetRegistry, request);
  }
 
  template <typename GetRegistryRequestT = Model::GetRegistryRequest>
  void GetRegistryAsync(const GetRegistryRequestT& request, const GetRegistryResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AgentRegistryControlClient::GetRegistry, request, handler, context);
  }
 
  virtual Model::GetRegistryRecordOutcome GetRegistryRecord(const Model::GetRegistryRecordRequest& request) const;
 
  template <typename GetRegistryRecordRequestT = Model::GetRegistryRecordRequest>
  Model::GetRegistryRecordOutcomeCallable GetRegistryRecordCallable(const GetRegistryRecordRequestT& request) const {
    return SubmitCallable(&AgentRegistryControlClient::GetRegistryRecord, request);
  }
 
  template <typename GetRegistryRecordRequestT = Model::GetRegistryRecordRequest>
  void GetRegistryRecordAsync(const GetRegistryRecordRequestT& request, const GetRegistryRecordResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AgentRegistryControlClient::GetRegistryRecord, request, handler, context);
  }
 
  virtual Model::ListRegistriesOutcome ListRegistries(const Model::ListRegistriesRequest& request = {}) const;
 
  template <typename ListRegistriesRequestT = Model::ListRegistriesRequest>
  Model::ListRegistriesOutcomeCallable ListRegistriesCallable(const ListRegistriesRequestT& request = {}) const {
    return SubmitCallable(&AgentRegistryControlClient::ListRegistries, request);
  }
 
  template <typename ListRegistriesRequestT = Model::ListRegistriesRequest>
  void ListRegistriesAsync(const ListRegistriesResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const ListRegistriesRequestT& request = {}) const {
    return SubmitAsync(&AgentRegistryControlClient::ListRegistries, request, handler, context);
  }
 
  virtual Model::ListRegistryRecordsOutcome ListRegistryRecords(const Model::ListRegistryRecordsRequest& request) const;
 
  template <typename ListRegistryRecordsRequestT = Model::ListRegistryRecordsRequest>
  Model::ListRegistryRecordsOutcomeCallable ListRegistryRecordsCallable(const ListRegistryRecordsRequestT& request) const {
    return SubmitCallable(&AgentRegistryControlClient::ListRegistryRecords, request);
  }
 
  template <typename ListRegistryRecordsRequestT = Model::ListRegistryRecordsRequest>
  void ListRegistryRecordsAsync(const ListRegistryRecordsRequestT& request, const ListRegistryRecordsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AgentRegistryControlClient::ListRegistryRecords, 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(&AgentRegistryControlClient::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(&AgentRegistryControlClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::SubmitRegistryRecordForApprovalOutcome SubmitRegistryRecordForApproval(
      const Model::SubmitRegistryRecordForApprovalRequest& request) const;
 
  template <typename SubmitRegistryRecordForApprovalRequestT = Model::SubmitRegistryRecordForApprovalRequest>
  Model::SubmitRegistryRecordForApprovalOutcomeCallable SubmitRegistryRecordForApprovalCallable(
      const SubmitRegistryRecordForApprovalRequestT& request) const {
    return SubmitCallable(&AgentRegistryControlClient::SubmitRegistryRecordForApproval, request);
  }
 
  template <typename SubmitRegistryRecordForApprovalRequestT = Model::SubmitRegistryRecordForApprovalRequest>
  void SubmitRegistryRecordForApprovalAsync(const SubmitRegistryRecordForApprovalRequestT& request,
                                            const SubmitRegistryRecordForApprovalResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AgentRegistryControlClient::SubmitRegistryRecordForApproval, 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(&AgentRegistryControlClient::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(&AgentRegistryControlClient::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(&AgentRegistryControlClient::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(&AgentRegistryControlClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateRegistryOutcome UpdateRegistry(const Model::UpdateRegistryRequest& request) const;
 
  template <typename UpdateRegistryRequestT = Model::UpdateRegistryRequest>
  Model::UpdateRegistryOutcomeCallable UpdateRegistryCallable(const UpdateRegistryRequestT& request) const {
    return SubmitCallable(&AgentRegistryControlClient::UpdateRegistry, request);
  }
 
  template <typename UpdateRegistryRequestT = Model::UpdateRegistryRequest>
  void UpdateRegistryAsync(const UpdateRegistryRequestT& request, const UpdateRegistryResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AgentRegistryControlClient::UpdateRegistry, request, handler, context);
  }
 
  virtual Model::UpdateRegistryRecordOutcome UpdateRegistryRecord(const Model::UpdateRegistryRecordRequest& request) const;
 
  template <typename UpdateRegistryRecordRequestT = Model::UpdateRegistryRecordRequest>
  Model::UpdateRegistryRecordOutcomeCallable UpdateRegistryRecordCallable(const UpdateRegistryRecordRequestT& request) const {
    return SubmitCallable(&AgentRegistryControlClient::UpdateRegistryRecord, request);
  }
 
  template <typename UpdateRegistryRecordRequestT = Model::UpdateRegistryRecordRequest>
  void UpdateRegistryRecordAsync(const UpdateRegistryRecordRequestT& request, const UpdateRegistryRecordResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AgentRegistryControlClient::UpdateRegistryRecord, request, handler, context);
  }
 
  virtual Model::UpdateRegistryRecordStatusOutcome UpdateRegistryRecordStatus(
      const Model::UpdateRegistryRecordStatusRequest& request) const;
 
  template <typename UpdateRegistryRecordStatusRequestT = Model::UpdateRegistryRecordStatusRequest>
  Model::UpdateRegistryRecordStatusOutcomeCallable UpdateRegistryRecordStatusCallable(
      const UpdateRegistryRecordStatusRequestT& request) const {
    return SubmitCallable(&AgentRegistryControlClient::UpdateRegistryRecordStatus, request);
  }
 
  template <typename UpdateRegistryRecordStatusRequestT = Model::UpdateRegistryRecordStatusRequest>
  void UpdateRegistryRecordStatusAsync(const UpdateRegistryRecordStatusRequestT& request,
                                       const UpdateRegistryRecordStatusResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AgentRegistryControlClient::UpdateRegistryRecordStatus, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<AgentRegistryControlEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<AgentRegistryControlClient>;
  void init(const AgentRegistryControlClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, AgentRegistryControlError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  AgentRegistryControlClientConfiguration m_clientConfiguration;
  std::shared_ptr<AgentRegistryControlEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace AgentRegistryControl
}  // namespace Aws