MQClient.h

 
#pragma once
#include <aws/mq/MQ_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/mq/MQServiceClientModel.h>
 
namespace Aws
{
namespace MQ
{
  class AWS_MQ_API MQClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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::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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<MQEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<MQClient>;
      void init(const MQClientConfiguration& clientConfiguration);
 
      MQClientConfiguration m_clientConfiguration;
      std::shared_ptr<MQEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace MQ
} // namespace Aws