MQClient.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/mq/MQPaginationBase.h>
#include <aws/mq/MQServiceClientModel.h>
#include <aws/mq/MQWaiter.h>
#include <aws/mq/MQ_EXPORTS.h>
 
namespace Aws {
namespace MQ {
class AWS_MQ_API MQClient : public Aws::Client::AWSJsonClient,
                            public Aws::Client::ClientWithAsyncTemplateMethods<MQClient>,
                            public MQPaginationBase<MQClient>,
                            public MQWaiter<MQClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef MQClientConfiguration ClientConfigurationType;
  typedef MQEndpointProvider EndpointProviderType;
 
  MQClient(const Aws::MQ::MQClientConfiguration& clientConfiguration = Aws::MQ::MQClientConfiguration(),
           std::shared_ptr<MQEndpointProviderBase> endpointProvider = nullptr);
 
  MQClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<MQEndpointProviderBase> endpointProvider = nullptr,
           const Aws::MQ::MQClientConfiguration& clientConfiguration = Aws::MQ::MQClientConfiguration());
 
  MQClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
           std::shared_ptr<MQEndpointProviderBase> endpointProvider = nullptr,
           const Aws::MQ::MQClientConfiguration& clientConfiguration = Aws::MQ::MQClientConfiguration());
 
  /* Legacy constructors due deprecation */
  MQClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  MQClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  MQClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
           const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~MQClient();
 
  virtual Model::CreateBrokerOutcome CreateBroker(const Model::CreateBrokerRequest& request) const;
 
  template <typename CreateBrokerRequestT = Model::CreateBrokerRequest>
  Model::CreateBrokerOutcomeCallable CreateBrokerCallable(const CreateBrokerRequestT& request) const {
    return SubmitCallable(&MQClient::CreateBroker, request);
  }
 
  template <typename CreateBrokerRequestT = Model::CreateBrokerRequest>
  void CreateBrokerAsync(const CreateBrokerRequestT& request, const CreateBrokerResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MQClient::CreateBroker, request, handler, context);
  }
 
  virtual Model::CreateConfigurationOutcome CreateConfiguration(const Model::CreateConfigurationRequest& request) const;
 
  template <typename CreateConfigurationRequestT = Model::CreateConfigurationRequest>
  Model::CreateConfigurationOutcomeCallable CreateConfigurationCallable(const CreateConfigurationRequestT& request) const {
    return SubmitCallable(&MQClient::CreateConfiguration, request);
  }
 
  template <typename CreateConfigurationRequestT = Model::CreateConfigurationRequest>
  void CreateConfigurationAsync(const CreateConfigurationRequestT& request, const CreateConfigurationResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MQClient::CreateConfiguration, request, handler, context);
  }
 
  virtual Model::CreateTagsOutcome CreateTags(const Model::CreateTagsRequest& request) const;
 
  template <typename CreateTagsRequestT = Model::CreateTagsRequest>
  Model::CreateTagsOutcomeCallable CreateTagsCallable(const CreateTagsRequestT& request) const {
    return SubmitCallable(&MQClient::CreateTags, request);
  }
 
  template <typename CreateTagsRequestT = Model::CreateTagsRequest>
  void CreateTagsAsync(const CreateTagsRequestT& request, const CreateTagsResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MQClient::CreateTags, request, handler, context);
  }
 
  virtual Model::CreateUserOutcome CreateUser(const Model::CreateUserRequest& request) const;
 
  template <typename CreateUserRequestT = Model::CreateUserRequest>
  Model::CreateUserOutcomeCallable CreateUserCallable(const CreateUserRequestT& request) const {
    return SubmitCallable(&MQClient::CreateUser, request);
  }
 
  template <typename CreateUserRequestT = Model::CreateUserRequest>
  void CreateUserAsync(const CreateUserRequestT& request, const CreateUserResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MQClient::CreateUser, request, handler, context);
  }
 
  virtual Model::DeleteBrokerOutcome DeleteBroker(const Model::DeleteBrokerRequest& request) const;
 
  template <typename DeleteBrokerRequestT = Model::DeleteBrokerRequest>
  Model::DeleteBrokerOutcomeCallable DeleteBrokerCallable(const DeleteBrokerRequestT& request) const {
    return SubmitCallable(&MQClient::DeleteBroker, request);
  }
 
  template <typename DeleteBrokerRequestT = Model::DeleteBrokerRequest>
  void DeleteBrokerAsync(const DeleteBrokerRequestT& request, const DeleteBrokerResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MQClient::DeleteBroker, request, handler, context);
  }
 
  virtual Model::DeleteConfigurationOutcome DeleteConfiguration(const Model::DeleteConfigurationRequest& request) const;
 
  template <typename DeleteConfigurationRequestT = Model::DeleteConfigurationRequest>
  Model::DeleteConfigurationOutcomeCallable DeleteConfigurationCallable(const DeleteConfigurationRequestT& request) const {
    return SubmitCallable(&MQClient::DeleteConfiguration, request);
  }
 
  template <typename DeleteConfigurationRequestT = Model::DeleteConfigurationRequest>
  void DeleteConfigurationAsync(const DeleteConfigurationRequestT& request, const DeleteConfigurationResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MQClient::DeleteConfiguration, request, handler, context);
  }
 
  virtual Model::DeleteTagsOutcome DeleteTags(const Model::DeleteTagsRequest& request) const;
 
  template <typename DeleteTagsRequestT = Model::DeleteTagsRequest>
  Model::DeleteTagsOutcomeCallable DeleteTagsCallable(const DeleteTagsRequestT& request) const {
    return SubmitCallable(&MQClient::DeleteTags, request);
  }
 
  template <typename DeleteTagsRequestT = Model::DeleteTagsRequest>
  void DeleteTagsAsync(const DeleteTagsRequestT& request, const DeleteTagsResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MQClient::DeleteTags, request, handler, context);
  }
 
  virtual Model::DeleteUserOutcome DeleteUser(const Model::DeleteUserRequest& request) const;
 
  template <typename DeleteUserRequestT = Model::DeleteUserRequest>
  Model::DeleteUserOutcomeCallable DeleteUserCallable(const DeleteUserRequestT& request) const {
    return SubmitCallable(&MQClient::DeleteUser, request);
  }
 
  template <typename DeleteUserRequestT = Model::DeleteUserRequest>
  void DeleteUserAsync(const DeleteUserRequestT& request, const DeleteUserResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MQClient::DeleteUser, request, handler, context);
  }
 
  virtual Model::DescribeBrokerOutcome DescribeBroker(const Model::DescribeBrokerRequest& request) const;
 
  template <typename DescribeBrokerRequestT = Model::DescribeBrokerRequest>
  Model::DescribeBrokerOutcomeCallable DescribeBrokerCallable(const DescribeBrokerRequestT& request) const {
    return SubmitCallable(&MQClient::DescribeBroker, request);
  }
 
  template <typename DescribeBrokerRequestT = Model::DescribeBrokerRequest>
  void DescribeBrokerAsync(const DescribeBrokerRequestT& request, const DescribeBrokerResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MQClient::DescribeBroker, request, handler, context);
  }
 
  virtual Model::DescribeBrokerEngineTypesOutcome DescribeBrokerEngineTypes(
      const Model::DescribeBrokerEngineTypesRequest& request = {}) const;
 
  template <typename DescribeBrokerEngineTypesRequestT = Model::DescribeBrokerEngineTypesRequest>
  Model::DescribeBrokerEngineTypesOutcomeCallable DescribeBrokerEngineTypesCallable(
      const DescribeBrokerEngineTypesRequestT& request = {}) const {
    return SubmitCallable(&MQClient::DescribeBrokerEngineTypes, request);
  }
 
  template <typename DescribeBrokerEngineTypesRequestT = Model::DescribeBrokerEngineTypesRequest>
  void DescribeBrokerEngineTypesAsync(const DescribeBrokerEngineTypesResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                      const DescribeBrokerEngineTypesRequestT& request = {}) const {
    return SubmitAsync(&MQClient::DescribeBrokerEngineTypes, request, handler, context);
  }
 
  virtual Model::DescribeBrokerInstanceOptionsOutcome DescribeBrokerInstanceOptions(
      const Model::DescribeBrokerInstanceOptionsRequest& request = {}) const;
 
  template <typename DescribeBrokerInstanceOptionsRequestT = Model::DescribeBrokerInstanceOptionsRequest>
  Model::DescribeBrokerInstanceOptionsOutcomeCallable DescribeBrokerInstanceOptionsCallable(
      const DescribeBrokerInstanceOptionsRequestT& request = {}) const {
    return SubmitCallable(&MQClient::DescribeBrokerInstanceOptions, request);
  }
 
  template <typename DescribeBrokerInstanceOptionsRequestT = Model::DescribeBrokerInstanceOptionsRequest>
  void DescribeBrokerInstanceOptionsAsync(const DescribeBrokerInstanceOptionsResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                          const DescribeBrokerInstanceOptionsRequestT& request = {}) const {
    return SubmitAsync(&MQClient::DescribeBrokerInstanceOptions, request, handler, context);
  }
 
  virtual Model::DescribeConfigurationOutcome DescribeConfiguration(const Model::DescribeConfigurationRequest& request) const;
 
  template <typename DescribeConfigurationRequestT = Model::DescribeConfigurationRequest>
  Model::DescribeConfigurationOutcomeCallable DescribeConfigurationCallable(const DescribeConfigurationRequestT& request) const {
    return SubmitCallable(&MQClient::DescribeConfiguration, request);
  }
 
  template <typename DescribeConfigurationRequestT = Model::DescribeConfigurationRequest>
  void DescribeConfigurationAsync(const DescribeConfigurationRequestT& request, const DescribeConfigurationResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MQClient::DescribeConfiguration, request, handler, context);
  }
 
  virtual Model::DescribeConfigurationRevisionOutcome DescribeConfigurationRevision(
      const Model::DescribeConfigurationRevisionRequest& request) const;
 
  template <typename DescribeConfigurationRevisionRequestT = Model::DescribeConfigurationRevisionRequest>
  Model::DescribeConfigurationRevisionOutcomeCallable DescribeConfigurationRevisionCallable(
      const DescribeConfigurationRevisionRequestT& request) const {
    return SubmitCallable(&MQClient::DescribeConfigurationRevision, request);
  }
 
  template <typename DescribeConfigurationRevisionRequestT = Model::DescribeConfigurationRevisionRequest>
  void DescribeConfigurationRevisionAsync(const DescribeConfigurationRevisionRequestT& request,
                                          const DescribeConfigurationRevisionResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MQClient::DescribeConfigurationRevision, request, handler, context);
  }
 
  virtual Model::DescribeUserOutcome DescribeUser(const Model::DescribeUserRequest& request) const;
 
  template <typename DescribeUserRequestT = Model::DescribeUserRequest>
  Model::DescribeUserOutcomeCallable DescribeUserCallable(const DescribeUserRequestT& request) const {
    return SubmitCallable(&MQClient::DescribeUser, request);
  }
 
  template <typename DescribeUserRequestT = Model::DescribeUserRequest>
  void DescribeUserAsync(const DescribeUserRequestT& request, const DescribeUserResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MQClient::DescribeUser, request, handler, context);
  }
 
  virtual Model::ListBrokersOutcome ListBrokers(const Model::ListBrokersRequest& request = {}) const;
 
  template <typename ListBrokersRequestT = Model::ListBrokersRequest>
  Model::ListBrokersOutcomeCallable ListBrokersCallable(const ListBrokersRequestT& request = {}) const {
    return SubmitCallable(&MQClient::ListBrokers, request);
  }
 
  template <typename ListBrokersRequestT = Model::ListBrokersRequest>
  void ListBrokersAsync(const ListBrokersResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                        const ListBrokersRequestT& request = {}) const {
    return SubmitAsync(&MQClient::ListBrokers, request, handler, context);
  }
 
  virtual Model::ListConfigurationRevisionsOutcome ListConfigurationRevisions(
      const Model::ListConfigurationRevisionsRequest& request) const;
 
  template <typename ListConfigurationRevisionsRequestT = Model::ListConfigurationRevisionsRequest>
  Model::ListConfigurationRevisionsOutcomeCallable ListConfigurationRevisionsCallable(
      const ListConfigurationRevisionsRequestT& request) const {
    return SubmitCallable(&MQClient::ListConfigurationRevisions, request);
  }
 
  template <typename ListConfigurationRevisionsRequestT = Model::ListConfigurationRevisionsRequest>
  void ListConfigurationRevisionsAsync(const ListConfigurationRevisionsRequestT& request,
                                       const ListConfigurationRevisionsResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MQClient::ListConfigurationRevisions, request, handler, context);
  }
 
  virtual Model::ListConfigurationsOutcome ListConfigurations(const Model::ListConfigurationsRequest& request = {}) const;
 
  template <typename ListConfigurationsRequestT = Model::ListConfigurationsRequest>
  Model::ListConfigurationsOutcomeCallable ListConfigurationsCallable(const ListConfigurationsRequestT& request = {}) const {
    return SubmitCallable(&MQClient::ListConfigurations, request);
  }
 
  template <typename ListConfigurationsRequestT = Model::ListConfigurationsRequest>
  void ListConfigurationsAsync(const ListConfigurationsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const ListConfigurationsRequestT& request = {}) const {
    return SubmitAsync(&MQClient::ListConfigurations, request, handler, context);
  }
 
  virtual Model::ListTagsOutcome ListTags(const Model::ListTagsRequest& request) const;
 
  template <typename ListTagsRequestT = Model::ListTagsRequest>
  Model::ListTagsOutcomeCallable ListTagsCallable(const ListTagsRequestT& request) const {
    return SubmitCallable(&MQClient::ListTags, request);
  }
 
  template <typename ListTagsRequestT = Model::ListTagsRequest>
  void ListTagsAsync(const ListTagsRequestT& request, const ListTagsResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MQClient::ListTags, request, handler, context);
  }
 
  virtual Model::ListUsersOutcome ListUsers(const Model::ListUsersRequest& request) const;
 
  template <typename ListUsersRequestT = Model::ListUsersRequest>
  Model::ListUsersOutcomeCallable ListUsersCallable(const ListUsersRequestT& request) const {
    return SubmitCallable(&MQClient::ListUsers, request);
  }
 
  template <typename ListUsersRequestT = Model::ListUsersRequest>
  void ListUsersAsync(const ListUsersRequestT& request, const ListUsersResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MQClient::ListUsers, request, handler, context);
  }
 
  virtual Model::PromoteOutcome Promote(const Model::PromoteRequest& request) const;
 
  template <typename PromoteRequestT = Model::PromoteRequest>
  Model::PromoteOutcomeCallable PromoteCallable(const PromoteRequestT& request) const {
    return SubmitCallable(&MQClient::Promote, request);
  }
 
  template <typename PromoteRequestT = Model::PromoteRequest>
  void PromoteAsync(const PromoteRequestT& request, const PromoteResponseReceivedHandler& handler,
                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MQClient::Promote, request, handler, context);
  }
 
  virtual Model::RebootBrokerOutcome RebootBroker(const Model::RebootBrokerRequest& request) const;
 
  template <typename RebootBrokerRequestT = Model::RebootBrokerRequest>
  Model::RebootBrokerOutcomeCallable RebootBrokerCallable(const RebootBrokerRequestT& request) const {
    return SubmitCallable(&MQClient::RebootBroker, request);
  }
 
  template <typename RebootBrokerRequestT = Model::RebootBrokerRequest>
  void RebootBrokerAsync(const RebootBrokerRequestT& request, const RebootBrokerResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MQClient::RebootBroker, request, handler, context);
  }
 
  virtual Model::UpdateBrokerOutcome UpdateBroker(const Model::UpdateBrokerRequest& request) const;
 
  template <typename UpdateBrokerRequestT = Model::UpdateBrokerRequest>
  Model::UpdateBrokerOutcomeCallable UpdateBrokerCallable(const UpdateBrokerRequestT& request) const {
    return SubmitCallable(&MQClient::UpdateBroker, request);
  }
 
  template <typename UpdateBrokerRequestT = Model::UpdateBrokerRequest>
  void UpdateBrokerAsync(const UpdateBrokerRequestT& request, const UpdateBrokerResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MQClient::UpdateBroker, request, handler, context);
  }
 
  virtual Model::UpdateConfigurationOutcome UpdateConfiguration(const Model::UpdateConfigurationRequest& request) const;
 
  template <typename UpdateConfigurationRequestT = Model::UpdateConfigurationRequest>
  Model::UpdateConfigurationOutcomeCallable UpdateConfigurationCallable(const UpdateConfigurationRequestT& request) const {
    return SubmitCallable(&MQClient::UpdateConfiguration, request);
  }
 
  template <typename UpdateConfigurationRequestT = Model::UpdateConfigurationRequest>
  void UpdateConfigurationAsync(const UpdateConfigurationRequestT& request, const UpdateConfigurationResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MQClient::UpdateConfiguration, request, handler, context);
  }
 
  virtual Model::UpdateUserOutcome UpdateUser(const Model::UpdateUserRequest& request) const;
 
  template <typename UpdateUserRequestT = Model::UpdateUserRequest>
  Model::UpdateUserOutcomeCallable UpdateUserCallable(const UpdateUserRequestT& request) const {
    return SubmitCallable(&MQClient::UpdateUser, request);
  }
 
  template <typename UpdateUserRequestT = Model::UpdateUserRequest>
  void UpdateUserAsync(const UpdateUserRequestT& request, const UpdateUserResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MQClient::UpdateUser, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<MQEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<MQClient>;
  void init(const MQClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, MQError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  MQClientConfiguration m_clientConfiguration;
  std::shared_ptr<MQEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace MQ
}  // namespace Aws