KafkaClient.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/kafka/KafkaPaginationBase.h>
#include <aws/kafka/KafkaServiceClientModel.h>
#include <aws/kafka/KafkaWaiter.h>
#include <aws/kafka/Kafka_EXPORTS.h>
 
namespace Aws {
namespace Kafka {
class AWS_KAFKA_API KafkaClient : public Aws::Client::AWSJsonClient,
                                  public Aws::Client::ClientWithAsyncTemplateMethods<KafkaClient>,
                                  public KafkaPaginationBase<KafkaClient>,
                                  public KafkaWaiter<KafkaClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef KafkaClientConfiguration ClientConfigurationType;
  typedef KafkaEndpointProvider EndpointProviderType;
 
  KafkaClient(const Aws::Kafka::KafkaClientConfiguration& clientConfiguration = Aws::Kafka::KafkaClientConfiguration(),
              std::shared_ptr<KafkaEndpointProviderBase> endpointProvider = nullptr);
 
  KafkaClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<KafkaEndpointProviderBase> endpointProvider = nullptr,
              const Aws::Kafka::KafkaClientConfiguration& clientConfiguration = Aws::Kafka::KafkaClientConfiguration());
 
  KafkaClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
              std::shared_ptr<KafkaEndpointProviderBase> endpointProvider = nullptr,
              const Aws::Kafka::KafkaClientConfiguration& clientConfiguration = Aws::Kafka::KafkaClientConfiguration());
 
  /* Legacy constructors due deprecation */
  KafkaClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  KafkaClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  KafkaClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
              const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~KafkaClient();
 
  virtual Model::BatchAssociateScramSecretOutcome BatchAssociateScramSecret(const Model::BatchAssociateScramSecretRequest& request) const;
 
  template <typename BatchAssociateScramSecretRequestT = Model::BatchAssociateScramSecretRequest>
  Model::BatchAssociateScramSecretOutcomeCallable BatchAssociateScramSecretCallable(
      const BatchAssociateScramSecretRequestT& request) const {
    return SubmitCallable(&KafkaClient::BatchAssociateScramSecret, request);
  }
 
  template <typename BatchAssociateScramSecretRequestT = Model::BatchAssociateScramSecretRequest>
  void BatchAssociateScramSecretAsync(const BatchAssociateScramSecretRequestT& request,
                                      const BatchAssociateScramSecretResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KafkaClient::BatchAssociateScramSecret, request, handler, context);
  }
 
  virtual Model::BatchDisassociateScramSecretOutcome BatchDisassociateScramSecret(
      const Model::BatchDisassociateScramSecretRequest& request) const;
 
  template <typename BatchDisassociateScramSecretRequestT = Model::BatchDisassociateScramSecretRequest>
  Model::BatchDisassociateScramSecretOutcomeCallable BatchDisassociateScramSecretCallable(
      const BatchDisassociateScramSecretRequestT& request) const {
    return SubmitCallable(&KafkaClient::BatchDisassociateScramSecret, request);
  }
 
  template <typename BatchDisassociateScramSecretRequestT = Model::BatchDisassociateScramSecretRequest>
  void BatchDisassociateScramSecretAsync(const BatchDisassociateScramSecretRequestT& request,
                                         const BatchDisassociateScramSecretResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KafkaClient::BatchDisassociateScramSecret, request, handler, context);
  }
 
  virtual Model::CreateChannelOutcome CreateChannel(const Model::CreateChannelRequest& request) const;
 
  template <typename CreateChannelRequestT = Model::CreateChannelRequest>
  Model::CreateChannelOutcomeCallable CreateChannelCallable(const CreateChannelRequestT& request) const {
    return SubmitCallable(&KafkaClient::CreateChannel, request);
  }
 
  template <typename CreateChannelRequestT = Model::CreateChannelRequest>
  void CreateChannelAsync(const CreateChannelRequestT& request, const CreateChannelResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KafkaClient::CreateChannel, request, handler, context);
  }
 
  virtual Model::CreateClusterOutcome CreateCluster(const Model::CreateClusterRequest& request) const;
 
  template <typename CreateClusterRequestT = Model::CreateClusterRequest>
  Model::CreateClusterOutcomeCallable CreateClusterCallable(const CreateClusterRequestT& request) const {
    return SubmitCallable(&KafkaClient::CreateCluster, request);
  }
 
  template <typename CreateClusterRequestT = Model::CreateClusterRequest>
  void CreateClusterAsync(const CreateClusterRequestT& request, const CreateClusterResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KafkaClient::CreateCluster, request, handler, context);
  }
 
  virtual Model::CreateClusterV2Outcome CreateClusterV2(const Model::CreateClusterV2Request& request) const;
 
  template <typename CreateClusterV2RequestT = Model::CreateClusterV2Request>
  Model::CreateClusterV2OutcomeCallable CreateClusterV2Callable(const CreateClusterV2RequestT& request) const {
    return SubmitCallable(&KafkaClient::CreateClusterV2, request);
  }
 
  template <typename CreateClusterV2RequestT = Model::CreateClusterV2Request>
  void CreateClusterV2Async(const CreateClusterV2RequestT& request, const CreateClusterV2ResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KafkaClient::CreateClusterV2, 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(&KafkaClient::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(&KafkaClient::CreateConfiguration, request, handler, context);
  }
 
  virtual Model::CreateReplicatorOutcome CreateReplicator(const Model::CreateReplicatorRequest& request) const;
 
  template <typename CreateReplicatorRequestT = Model::CreateReplicatorRequest>
  Model::CreateReplicatorOutcomeCallable CreateReplicatorCallable(const CreateReplicatorRequestT& request) const {
    return SubmitCallable(&KafkaClient::CreateReplicator, request);
  }
 
  template <typename CreateReplicatorRequestT = Model::CreateReplicatorRequest>
  void CreateReplicatorAsync(const CreateReplicatorRequestT& request, const CreateReplicatorResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KafkaClient::CreateReplicator, request, handler, context);
  }
 
  virtual Model::CreateTopicOutcome CreateTopic(const Model::CreateTopicRequest& request) const;
 
  template <typename CreateTopicRequestT = Model::CreateTopicRequest>
  Model::CreateTopicOutcomeCallable CreateTopicCallable(const CreateTopicRequestT& request) const {
    return SubmitCallable(&KafkaClient::CreateTopic, request);
  }
 
  template <typename CreateTopicRequestT = Model::CreateTopicRequest>
  void CreateTopicAsync(const CreateTopicRequestT& request, const CreateTopicResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KafkaClient::CreateTopic, request, handler, context);
  }
 
  virtual Model::CreateVpcConnectionOutcome CreateVpcConnection(const Model::CreateVpcConnectionRequest& request) const;
 
  template <typename CreateVpcConnectionRequestT = Model::CreateVpcConnectionRequest>
  Model::CreateVpcConnectionOutcomeCallable CreateVpcConnectionCallable(const CreateVpcConnectionRequestT& request) const {
    return SubmitCallable(&KafkaClient::CreateVpcConnection, request);
  }
 
  template <typename CreateVpcConnectionRequestT = Model::CreateVpcConnectionRequest>
  void CreateVpcConnectionAsync(const CreateVpcConnectionRequestT& request, const CreateVpcConnectionResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KafkaClient::CreateVpcConnection, request, handler, context);
  }
 
  virtual Model::DeleteChannelOutcome DeleteChannel(const Model::DeleteChannelRequest& request) const;
 
  template <typename DeleteChannelRequestT = Model::DeleteChannelRequest>
  Model::DeleteChannelOutcomeCallable DeleteChannelCallable(const DeleteChannelRequestT& request) const {
    return SubmitCallable(&KafkaClient::DeleteChannel, request);
  }
 
  template <typename DeleteChannelRequestT = Model::DeleteChannelRequest>
  void DeleteChannelAsync(const DeleteChannelRequestT& request, const DeleteChannelResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KafkaClient::DeleteChannel, request, handler, context);
  }
 
  virtual Model::DeleteClusterOutcome DeleteCluster(const Model::DeleteClusterRequest& request) const;
 
  template <typename DeleteClusterRequestT = Model::DeleteClusterRequest>
  Model::DeleteClusterOutcomeCallable DeleteClusterCallable(const DeleteClusterRequestT& request) const {
    return SubmitCallable(&KafkaClient::DeleteCluster, request);
  }
 
  template <typename DeleteClusterRequestT = Model::DeleteClusterRequest>
  void DeleteClusterAsync(const DeleteClusterRequestT& request, const DeleteClusterResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KafkaClient::DeleteCluster, request, handler, context);
  }
 
  virtual Model::DeleteClusterPolicyOutcome DeleteClusterPolicy(const Model::DeleteClusterPolicyRequest& request) const;
 
  template <typename DeleteClusterPolicyRequestT = Model::DeleteClusterPolicyRequest>
  Model::DeleteClusterPolicyOutcomeCallable DeleteClusterPolicyCallable(const DeleteClusterPolicyRequestT& request) const {
    return SubmitCallable(&KafkaClient::DeleteClusterPolicy, request);
  }
 
  template <typename DeleteClusterPolicyRequestT = Model::DeleteClusterPolicyRequest>
  void DeleteClusterPolicyAsync(const DeleteClusterPolicyRequestT& request, const DeleteClusterPolicyResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KafkaClient::DeleteClusterPolicy, 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(&KafkaClient::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(&KafkaClient::DeleteConfiguration, request, handler, context);
  }
 
  virtual Model::DeleteReplicatorOutcome DeleteReplicator(const Model::DeleteReplicatorRequest& request) const;
 
  template <typename DeleteReplicatorRequestT = Model::DeleteReplicatorRequest>
  Model::DeleteReplicatorOutcomeCallable DeleteReplicatorCallable(const DeleteReplicatorRequestT& request) const {
    return SubmitCallable(&KafkaClient::DeleteReplicator, request);
  }
 
  template <typename DeleteReplicatorRequestT = Model::DeleteReplicatorRequest>
  void DeleteReplicatorAsync(const DeleteReplicatorRequestT& request, const DeleteReplicatorResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KafkaClient::DeleteReplicator, request, handler, context);
  }
 
  virtual Model::DeleteTopicOutcome DeleteTopic(const Model::DeleteTopicRequest& request) const;
 
  template <typename DeleteTopicRequestT = Model::DeleteTopicRequest>
  Model::DeleteTopicOutcomeCallable DeleteTopicCallable(const DeleteTopicRequestT& request) const {
    return SubmitCallable(&KafkaClient::DeleteTopic, request);
  }
 
  template <typename DeleteTopicRequestT = Model::DeleteTopicRequest>
  void DeleteTopicAsync(const DeleteTopicRequestT& request, const DeleteTopicResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KafkaClient::DeleteTopic, request, handler, context);
  }
 
  virtual Model::DeleteVpcConnectionOutcome DeleteVpcConnection(const Model::DeleteVpcConnectionRequest& request) const;
 
  template <typename DeleteVpcConnectionRequestT = Model::DeleteVpcConnectionRequest>
  Model::DeleteVpcConnectionOutcomeCallable DeleteVpcConnectionCallable(const DeleteVpcConnectionRequestT& request) const {
    return SubmitCallable(&KafkaClient::DeleteVpcConnection, request);
  }
 
  template <typename DeleteVpcConnectionRequestT = Model::DeleteVpcConnectionRequest>
  void DeleteVpcConnectionAsync(const DeleteVpcConnectionRequestT& request, const DeleteVpcConnectionResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KafkaClient::DeleteVpcConnection, request, handler, context);
  }
 
  virtual Model::DescribeChannelOutcome DescribeChannel(const Model::DescribeChannelRequest& request) const;
 
  template <typename DescribeChannelRequestT = Model::DescribeChannelRequest>
  Model::DescribeChannelOutcomeCallable DescribeChannelCallable(const DescribeChannelRequestT& request) const {
    return SubmitCallable(&KafkaClient::DescribeChannel, request);
  }
 
  template <typename DescribeChannelRequestT = Model::DescribeChannelRequest>
  void DescribeChannelAsync(const DescribeChannelRequestT& request, const DescribeChannelResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KafkaClient::DescribeChannel, request, handler, context);
  }
 
  virtual Model::DescribeClusterOutcome DescribeCluster(const Model::DescribeClusterRequest& request) const;
 
  template <typename DescribeClusterRequestT = Model::DescribeClusterRequest>
  Model::DescribeClusterOutcomeCallable DescribeClusterCallable(const DescribeClusterRequestT& request) const {
    return SubmitCallable(&KafkaClient::DescribeCluster, request);
  }
 
  template <typename DescribeClusterRequestT = Model::DescribeClusterRequest>
  void DescribeClusterAsync(const DescribeClusterRequestT& request, const DescribeClusterResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KafkaClient::DescribeCluster, request, handler, context);
  }
 
  virtual Model::DescribeClusterOperationOutcome DescribeClusterOperation(const Model::DescribeClusterOperationRequest& request) const;
 
  template <typename DescribeClusterOperationRequestT = Model::DescribeClusterOperationRequest>
  Model::DescribeClusterOperationOutcomeCallable DescribeClusterOperationCallable(const DescribeClusterOperationRequestT& request) const {
    return SubmitCallable(&KafkaClient::DescribeClusterOperation, request);
  }
 
  template <typename DescribeClusterOperationRequestT = Model::DescribeClusterOperationRequest>
  void DescribeClusterOperationAsync(const DescribeClusterOperationRequestT& request,
                                     const DescribeClusterOperationResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KafkaClient::DescribeClusterOperation, request, handler, context);
  }
 
  virtual Model::DescribeClusterOperationV2Outcome DescribeClusterOperationV2(
      const Model::DescribeClusterOperationV2Request& request) const;
 
  template <typename DescribeClusterOperationV2RequestT = Model::DescribeClusterOperationV2Request>
  Model::DescribeClusterOperationV2OutcomeCallable DescribeClusterOperationV2Callable(
      const DescribeClusterOperationV2RequestT& request) const {
    return SubmitCallable(&KafkaClient::DescribeClusterOperationV2, request);
  }
 
  template <typename DescribeClusterOperationV2RequestT = Model::DescribeClusterOperationV2Request>
  void DescribeClusterOperationV2Async(const DescribeClusterOperationV2RequestT& request,
                                       const DescribeClusterOperationV2ResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KafkaClient::DescribeClusterOperationV2, request, handler, context);
  }
 
  virtual Model::DescribeClusterV2Outcome DescribeClusterV2(const Model::DescribeClusterV2Request& request) const;
 
  template <typename DescribeClusterV2RequestT = Model::DescribeClusterV2Request>
  Model::DescribeClusterV2OutcomeCallable DescribeClusterV2Callable(const DescribeClusterV2RequestT& request) const {
    return SubmitCallable(&KafkaClient::DescribeClusterV2, request);
  }
 
  template <typename DescribeClusterV2RequestT = Model::DescribeClusterV2Request>
  void DescribeClusterV2Async(const DescribeClusterV2RequestT& request, const DescribeClusterV2ResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KafkaClient::DescribeClusterV2, 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(&KafkaClient::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(&KafkaClient::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(&KafkaClient::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(&KafkaClient::DescribeConfigurationRevision, request, handler, context);
  }
 
  virtual Model::DescribeReplicatorOutcome DescribeReplicator(const Model::DescribeReplicatorRequest& request) const;
 
  template <typename DescribeReplicatorRequestT = Model::DescribeReplicatorRequest>
  Model::DescribeReplicatorOutcomeCallable DescribeReplicatorCallable(const DescribeReplicatorRequestT& request) const {
    return SubmitCallable(&KafkaClient::DescribeReplicator, request);
  }
 
  template <typename DescribeReplicatorRequestT = Model::DescribeReplicatorRequest>
  void DescribeReplicatorAsync(const DescribeReplicatorRequestT& request, const DescribeReplicatorResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KafkaClient::DescribeReplicator, request, handler, context);
  }
 
  virtual Model::DescribeTopicOutcome DescribeTopic(const Model::DescribeTopicRequest& request) const;
 
  template <typename DescribeTopicRequestT = Model::DescribeTopicRequest>
  Model::DescribeTopicOutcomeCallable DescribeTopicCallable(const DescribeTopicRequestT& request) const {
    return SubmitCallable(&KafkaClient::DescribeTopic, request);
  }
 
  template <typename DescribeTopicRequestT = Model::DescribeTopicRequest>
  void DescribeTopicAsync(const DescribeTopicRequestT& request, const DescribeTopicResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KafkaClient::DescribeTopic, request, handler, context);
  }
 
  virtual Model::DescribeTopicPartitionsOutcome DescribeTopicPartitions(const Model::DescribeTopicPartitionsRequest& request) const;
 
  template <typename DescribeTopicPartitionsRequestT = Model::DescribeTopicPartitionsRequest>
  Model::DescribeTopicPartitionsOutcomeCallable DescribeTopicPartitionsCallable(const DescribeTopicPartitionsRequestT& request) const {
    return SubmitCallable(&KafkaClient::DescribeTopicPartitions, request);
  }
 
  template <typename DescribeTopicPartitionsRequestT = Model::DescribeTopicPartitionsRequest>
  void DescribeTopicPartitionsAsync(const DescribeTopicPartitionsRequestT& request,
                                    const DescribeTopicPartitionsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KafkaClient::DescribeTopicPartitions, request, handler, context);
  }
 
  virtual Model::DescribeVpcConnectionOutcome DescribeVpcConnection(const Model::DescribeVpcConnectionRequest& request) const;
 
  template <typename DescribeVpcConnectionRequestT = Model::DescribeVpcConnectionRequest>
  Model::DescribeVpcConnectionOutcomeCallable DescribeVpcConnectionCallable(const DescribeVpcConnectionRequestT& request) const {
    return SubmitCallable(&KafkaClient::DescribeVpcConnection, request);
  }
 
  template <typename DescribeVpcConnectionRequestT = Model::DescribeVpcConnectionRequest>
  void DescribeVpcConnectionAsync(const DescribeVpcConnectionRequestT& request, const DescribeVpcConnectionResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KafkaClient::DescribeVpcConnection, request, handler, context);
  }
 
  virtual Model::GetBootstrapBrokersOutcome GetBootstrapBrokers(const Model::GetBootstrapBrokersRequest& request) const;
 
  template <typename GetBootstrapBrokersRequestT = Model::GetBootstrapBrokersRequest>
  Model::GetBootstrapBrokersOutcomeCallable GetBootstrapBrokersCallable(const GetBootstrapBrokersRequestT& request) const {
    return SubmitCallable(&KafkaClient::GetBootstrapBrokers, request);
  }
 
  template <typename GetBootstrapBrokersRequestT = Model::GetBootstrapBrokersRequest>
  void GetBootstrapBrokersAsync(const GetBootstrapBrokersRequestT& request, const GetBootstrapBrokersResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KafkaClient::GetBootstrapBrokers, request, handler, context);
  }
 
  virtual Model::GetClusterPolicyOutcome GetClusterPolicy(const Model::GetClusterPolicyRequest& request) const;
 
  template <typename GetClusterPolicyRequestT = Model::GetClusterPolicyRequest>
  Model::GetClusterPolicyOutcomeCallable GetClusterPolicyCallable(const GetClusterPolicyRequestT& request) const {
    return SubmitCallable(&KafkaClient::GetClusterPolicy, request);
  }
 
  template <typename GetClusterPolicyRequestT = Model::GetClusterPolicyRequest>
  void GetClusterPolicyAsync(const GetClusterPolicyRequestT& request, const GetClusterPolicyResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KafkaClient::GetClusterPolicy, request, handler, context);
  }
 
  virtual Model::GetCompatibleKafkaVersionsOutcome GetCompatibleKafkaVersions(
      const Model::GetCompatibleKafkaVersionsRequest& request = {}) const;
 
  template <typename GetCompatibleKafkaVersionsRequestT = Model::GetCompatibleKafkaVersionsRequest>
  Model::GetCompatibleKafkaVersionsOutcomeCallable GetCompatibleKafkaVersionsCallable(
      const GetCompatibleKafkaVersionsRequestT& request = {}) const {
    return SubmitCallable(&KafkaClient::GetCompatibleKafkaVersions, request);
  }
 
  template <typename GetCompatibleKafkaVersionsRequestT = Model::GetCompatibleKafkaVersionsRequest>
  void GetCompatibleKafkaVersionsAsync(const GetCompatibleKafkaVersionsResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                       const GetCompatibleKafkaVersionsRequestT& request = {}) const {
    return SubmitAsync(&KafkaClient::GetCompatibleKafkaVersions, request, handler, context);
  }
 
  virtual Model::ListChannelsOutcome ListChannels(const Model::ListChannelsRequest& request) const;
 
  template <typename ListChannelsRequestT = Model::ListChannelsRequest>
  Model::ListChannelsOutcomeCallable ListChannelsCallable(const ListChannelsRequestT& request) const {
    return SubmitCallable(&KafkaClient::ListChannels, request);
  }
 
  template <typename ListChannelsRequestT = Model::ListChannelsRequest>
  void ListChannelsAsync(const ListChannelsRequestT& request, const ListChannelsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KafkaClient::ListChannels, request, handler, context);
  }
 
  virtual Model::ListClientVpcConnectionsOutcome ListClientVpcConnections(const Model::ListClientVpcConnectionsRequest& request) const;
 
  template <typename ListClientVpcConnectionsRequestT = Model::ListClientVpcConnectionsRequest>
  Model::ListClientVpcConnectionsOutcomeCallable ListClientVpcConnectionsCallable(const ListClientVpcConnectionsRequestT& request) const {
    return SubmitCallable(&KafkaClient::ListClientVpcConnections, request);
  }
 
  template <typename ListClientVpcConnectionsRequestT = Model::ListClientVpcConnectionsRequest>
  void ListClientVpcConnectionsAsync(const ListClientVpcConnectionsRequestT& request,
                                     const ListClientVpcConnectionsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KafkaClient::ListClientVpcConnections, request, handler, context);
  }
 
  virtual Model::ListClusterOperationsOutcome ListClusterOperations(const Model::ListClusterOperationsRequest& request) const;
 
  template <typename ListClusterOperationsRequestT = Model::ListClusterOperationsRequest>
  Model::ListClusterOperationsOutcomeCallable ListClusterOperationsCallable(const ListClusterOperationsRequestT& request) const {
    return SubmitCallable(&KafkaClient::ListClusterOperations, request);
  }
 
  template <typename ListClusterOperationsRequestT = Model::ListClusterOperationsRequest>
  void ListClusterOperationsAsync(const ListClusterOperationsRequestT& request, const ListClusterOperationsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KafkaClient::ListClusterOperations, request, handler, context);
  }
 
  virtual Model::ListClusterOperationsV2Outcome ListClusterOperationsV2(const Model::ListClusterOperationsV2Request& request) const;
 
  template <typename ListClusterOperationsV2RequestT = Model::ListClusterOperationsV2Request>
  Model::ListClusterOperationsV2OutcomeCallable ListClusterOperationsV2Callable(const ListClusterOperationsV2RequestT& request) const {
    return SubmitCallable(&KafkaClient::ListClusterOperationsV2, request);
  }
 
  template <typename ListClusterOperationsV2RequestT = Model::ListClusterOperationsV2Request>
  void ListClusterOperationsV2Async(const ListClusterOperationsV2RequestT& request,
                                    const ListClusterOperationsV2ResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KafkaClient::ListClusterOperationsV2, request, handler, context);
  }
 
  virtual Model::ListClustersOutcome ListClusters(const Model::ListClustersRequest& request = {}) const;
 
  template <typename ListClustersRequestT = Model::ListClustersRequest>
  Model::ListClustersOutcomeCallable ListClustersCallable(const ListClustersRequestT& request = {}) const {
    return SubmitCallable(&KafkaClient::ListClusters, request);
  }
 
  template <typename ListClustersRequestT = Model::ListClustersRequest>
  void ListClustersAsync(const ListClustersResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const ListClustersRequestT& request = {}) const {
    return SubmitAsync(&KafkaClient::ListClusters, request, handler, context);
  }
 
  virtual Model::ListClustersV2Outcome ListClustersV2(const Model::ListClustersV2Request& request = {}) const;
 
  template <typename ListClustersV2RequestT = Model::ListClustersV2Request>
  Model::ListClustersV2OutcomeCallable ListClustersV2Callable(const ListClustersV2RequestT& request = {}) const {
    return SubmitCallable(&KafkaClient::ListClustersV2, request);
  }
 
  template <typename ListClustersV2RequestT = Model::ListClustersV2Request>
  void ListClustersV2Async(const ListClustersV2ResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const ListClustersV2RequestT& request = {}) const {
    return SubmitAsync(&KafkaClient::ListClustersV2, 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(&KafkaClient::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(&KafkaClient::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(&KafkaClient::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(&KafkaClient::ListConfigurations, request, handler, context);
  }
 
  virtual Model::ListKafkaVersionsOutcome ListKafkaVersions(const Model::ListKafkaVersionsRequest& request = {}) const;
 
  template <typename ListKafkaVersionsRequestT = Model::ListKafkaVersionsRequest>
  Model::ListKafkaVersionsOutcomeCallable ListKafkaVersionsCallable(const ListKafkaVersionsRequestT& request = {}) const {
    return SubmitCallable(&KafkaClient::ListKafkaVersions, request);
  }
 
  template <typename ListKafkaVersionsRequestT = Model::ListKafkaVersionsRequest>
  void ListKafkaVersionsAsync(const ListKafkaVersionsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const ListKafkaVersionsRequestT& request = {}) const {
    return SubmitAsync(&KafkaClient::ListKafkaVersions, request, handler, context);
  }
 
  virtual Model::ListNodesOutcome ListNodes(const Model::ListNodesRequest& request) const;
 
  template <typename ListNodesRequestT = Model::ListNodesRequest>
  Model::ListNodesOutcomeCallable ListNodesCallable(const ListNodesRequestT& request) const {
    return SubmitCallable(&KafkaClient::ListNodes, request);
  }
 
  template <typename ListNodesRequestT = Model::ListNodesRequest>
  void ListNodesAsync(const ListNodesRequestT& request, const ListNodesResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KafkaClient::ListNodes, request, handler, context);
  }
 
  virtual Model::ListReplicatorsOutcome ListReplicators(const Model::ListReplicatorsRequest& request = {}) const;
 
  template <typename ListReplicatorsRequestT = Model::ListReplicatorsRequest>
  Model::ListReplicatorsOutcomeCallable ListReplicatorsCallable(const ListReplicatorsRequestT& request = {}) const {
    return SubmitCallable(&KafkaClient::ListReplicators, request);
  }
 
  template <typename ListReplicatorsRequestT = Model::ListReplicatorsRequest>
  void ListReplicatorsAsync(const ListReplicatorsResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                            const ListReplicatorsRequestT& request = {}) const {
    return SubmitAsync(&KafkaClient::ListReplicators, request, handler, context);
  }
 
  virtual Model::ListScramSecretsOutcome ListScramSecrets(const Model::ListScramSecretsRequest& request) const;
 
  template <typename ListScramSecretsRequestT = Model::ListScramSecretsRequest>
  Model::ListScramSecretsOutcomeCallable ListScramSecretsCallable(const ListScramSecretsRequestT& request) const {
    return SubmitCallable(&KafkaClient::ListScramSecrets, request);
  }
 
  template <typename ListScramSecretsRequestT = Model::ListScramSecretsRequest>
  void ListScramSecretsAsync(const ListScramSecretsRequestT& request, const ListScramSecretsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KafkaClient::ListScramSecrets, 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(&KafkaClient::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(&KafkaClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::ListTopicsOutcome ListTopics(const Model::ListTopicsRequest& request) const;
 
  template <typename ListTopicsRequestT = Model::ListTopicsRequest>
  Model::ListTopicsOutcomeCallable ListTopicsCallable(const ListTopicsRequestT& request) const {
    return SubmitCallable(&KafkaClient::ListTopics, request);
  }
 
  template <typename ListTopicsRequestT = Model::ListTopicsRequest>
  void ListTopicsAsync(const ListTopicsRequestT& request, const ListTopicsResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KafkaClient::ListTopics, request, handler, context);
  }
 
  virtual Model::ListVpcConnectionsOutcome ListVpcConnections(const Model::ListVpcConnectionsRequest& request = {}) const;
 
  template <typename ListVpcConnectionsRequestT = Model::ListVpcConnectionsRequest>
  Model::ListVpcConnectionsOutcomeCallable ListVpcConnectionsCallable(const ListVpcConnectionsRequestT& request = {}) const {
    return SubmitCallable(&KafkaClient::ListVpcConnections, request);
  }
 
  template <typename ListVpcConnectionsRequestT = Model::ListVpcConnectionsRequest>
  void ListVpcConnectionsAsync(const ListVpcConnectionsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const ListVpcConnectionsRequestT& request = {}) const {
    return SubmitAsync(&KafkaClient::ListVpcConnections, request, handler, context);
  }
 
  virtual Model::PutClusterPolicyOutcome PutClusterPolicy(const Model::PutClusterPolicyRequest& request) const;
 
  template <typename PutClusterPolicyRequestT = Model::PutClusterPolicyRequest>
  Model::PutClusterPolicyOutcomeCallable PutClusterPolicyCallable(const PutClusterPolicyRequestT& request) const {
    return SubmitCallable(&KafkaClient::PutClusterPolicy, request);
  }
 
  template <typename PutClusterPolicyRequestT = Model::PutClusterPolicyRequest>
  void PutClusterPolicyAsync(const PutClusterPolicyRequestT& request, const PutClusterPolicyResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KafkaClient::PutClusterPolicy, 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(&KafkaClient::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(&KafkaClient::RebootBroker, request, handler, context);
  }
 
  virtual Model::RejectClientVpcConnectionOutcome RejectClientVpcConnection(const Model::RejectClientVpcConnectionRequest& request) const;
 
  template <typename RejectClientVpcConnectionRequestT = Model::RejectClientVpcConnectionRequest>
  Model::RejectClientVpcConnectionOutcomeCallable RejectClientVpcConnectionCallable(
      const RejectClientVpcConnectionRequestT& request) const {
    return SubmitCallable(&KafkaClient::RejectClientVpcConnection, request);
  }
 
  template <typename RejectClientVpcConnectionRequestT = Model::RejectClientVpcConnectionRequest>
  void RejectClientVpcConnectionAsync(const RejectClientVpcConnectionRequestT& request,
                                      const RejectClientVpcConnectionResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KafkaClient::RejectClientVpcConnection, 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(&KafkaClient::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(&KafkaClient::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(&KafkaClient::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(&KafkaClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateBrokerCountOutcome UpdateBrokerCount(const Model::UpdateBrokerCountRequest& request) const;
 
  template <typename UpdateBrokerCountRequestT = Model::UpdateBrokerCountRequest>
  Model::UpdateBrokerCountOutcomeCallable UpdateBrokerCountCallable(const UpdateBrokerCountRequestT& request) const {
    return SubmitCallable(&KafkaClient::UpdateBrokerCount, request);
  }
 
  template <typename UpdateBrokerCountRequestT = Model::UpdateBrokerCountRequest>
  void UpdateBrokerCountAsync(const UpdateBrokerCountRequestT& request, const UpdateBrokerCountResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KafkaClient::UpdateBrokerCount, request, handler, context);
  }
 
  virtual Model::UpdateBrokerStorageOutcome UpdateBrokerStorage(const Model::UpdateBrokerStorageRequest& request) const;
 
  template <typename UpdateBrokerStorageRequestT = Model::UpdateBrokerStorageRequest>
  Model::UpdateBrokerStorageOutcomeCallable UpdateBrokerStorageCallable(const UpdateBrokerStorageRequestT& request) const {
    return SubmitCallable(&KafkaClient::UpdateBrokerStorage, request);
  }
 
  template <typename UpdateBrokerStorageRequestT = Model::UpdateBrokerStorageRequest>
  void UpdateBrokerStorageAsync(const UpdateBrokerStorageRequestT& request, const UpdateBrokerStorageResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KafkaClient::UpdateBrokerStorage, request, handler, context);
  }
 
  virtual Model::UpdateBrokerTypeOutcome UpdateBrokerType(const Model::UpdateBrokerTypeRequest& request) const;
 
  template <typename UpdateBrokerTypeRequestT = Model::UpdateBrokerTypeRequest>
  Model::UpdateBrokerTypeOutcomeCallable UpdateBrokerTypeCallable(const UpdateBrokerTypeRequestT& request) const {
    return SubmitCallable(&KafkaClient::UpdateBrokerType, request);
  }
 
  template <typename UpdateBrokerTypeRequestT = Model::UpdateBrokerTypeRequest>
  void UpdateBrokerTypeAsync(const UpdateBrokerTypeRequestT& request, const UpdateBrokerTypeResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KafkaClient::UpdateBrokerType, request, handler, context);
  }
 
  virtual Model::UpdateChannelOutcome UpdateChannel(const Model::UpdateChannelRequest& request) const;
 
  template <typename UpdateChannelRequestT = Model::UpdateChannelRequest>
  Model::UpdateChannelOutcomeCallable UpdateChannelCallable(const UpdateChannelRequestT& request) const {
    return SubmitCallable(&KafkaClient::UpdateChannel, request);
  }
 
  template <typename UpdateChannelRequestT = Model::UpdateChannelRequest>
  void UpdateChannelAsync(const UpdateChannelRequestT& request, const UpdateChannelResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KafkaClient::UpdateChannel, request, handler, context);
  }
 
  virtual Model::UpdateClusterConfigurationOutcome UpdateClusterConfiguration(
      const Model::UpdateClusterConfigurationRequest& request) const;
 
  template <typename UpdateClusterConfigurationRequestT = Model::UpdateClusterConfigurationRequest>
  Model::UpdateClusterConfigurationOutcomeCallable UpdateClusterConfigurationCallable(
      const UpdateClusterConfigurationRequestT& request) const {
    return SubmitCallable(&KafkaClient::UpdateClusterConfiguration, request);
  }
 
  template <typename UpdateClusterConfigurationRequestT = Model::UpdateClusterConfigurationRequest>
  void UpdateClusterConfigurationAsync(const UpdateClusterConfigurationRequestT& request,
                                       const UpdateClusterConfigurationResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KafkaClient::UpdateClusterConfiguration, request, handler, context);
  }
 
  virtual Model::UpdateClusterKafkaVersionOutcome UpdateClusterKafkaVersion(const Model::UpdateClusterKafkaVersionRequest& request) const;
 
  template <typename UpdateClusterKafkaVersionRequestT = Model::UpdateClusterKafkaVersionRequest>
  Model::UpdateClusterKafkaVersionOutcomeCallable UpdateClusterKafkaVersionCallable(
      const UpdateClusterKafkaVersionRequestT& request) const {
    return SubmitCallable(&KafkaClient::UpdateClusterKafkaVersion, request);
  }
 
  template <typename UpdateClusterKafkaVersionRequestT = Model::UpdateClusterKafkaVersionRequest>
  void UpdateClusterKafkaVersionAsync(const UpdateClusterKafkaVersionRequestT& request,
                                      const UpdateClusterKafkaVersionResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KafkaClient::UpdateClusterKafkaVersion, 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(&KafkaClient::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(&KafkaClient::UpdateConfiguration, request, handler, context);
  }
 
  virtual Model::UpdateConnectivityOutcome UpdateConnectivity(const Model::UpdateConnectivityRequest& request) const;
 
  template <typename UpdateConnectivityRequestT = Model::UpdateConnectivityRequest>
  Model::UpdateConnectivityOutcomeCallable UpdateConnectivityCallable(const UpdateConnectivityRequestT& request) const {
    return SubmitCallable(&KafkaClient::UpdateConnectivity, request);
  }
 
  template <typename UpdateConnectivityRequestT = Model::UpdateConnectivityRequest>
  void UpdateConnectivityAsync(const UpdateConnectivityRequestT& request, const UpdateConnectivityResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KafkaClient::UpdateConnectivity, request, handler, context);
  }
 
  virtual Model::UpdateMonitoringOutcome UpdateMonitoring(const Model::UpdateMonitoringRequest& request) const;
 
  template <typename UpdateMonitoringRequestT = Model::UpdateMonitoringRequest>
  Model::UpdateMonitoringOutcomeCallable UpdateMonitoringCallable(const UpdateMonitoringRequestT& request) const {
    return SubmitCallable(&KafkaClient::UpdateMonitoring, request);
  }
 
  template <typename UpdateMonitoringRequestT = Model::UpdateMonitoringRequest>
  void UpdateMonitoringAsync(const UpdateMonitoringRequestT& request, const UpdateMonitoringResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KafkaClient::UpdateMonitoring, request, handler, context);
  }
 
  virtual Model::UpdateRebalancingOutcome UpdateRebalancing(const Model::UpdateRebalancingRequest& request) const;
 
  template <typename UpdateRebalancingRequestT = Model::UpdateRebalancingRequest>
  Model::UpdateRebalancingOutcomeCallable UpdateRebalancingCallable(const UpdateRebalancingRequestT& request) const {
    return SubmitCallable(&KafkaClient::UpdateRebalancing, request);
  }
 
  template <typename UpdateRebalancingRequestT = Model::UpdateRebalancingRequest>
  void UpdateRebalancingAsync(const UpdateRebalancingRequestT& request, const UpdateRebalancingResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KafkaClient::UpdateRebalancing, request, handler, context);
  }
 
  virtual Model::UpdateReplicationInfoOutcome UpdateReplicationInfo(const Model::UpdateReplicationInfoRequest& request) const;
 
  template <typename UpdateReplicationInfoRequestT = Model::UpdateReplicationInfoRequest>
  Model::UpdateReplicationInfoOutcomeCallable UpdateReplicationInfoCallable(const UpdateReplicationInfoRequestT& request) const {
    return SubmitCallable(&KafkaClient::UpdateReplicationInfo, request);
  }
 
  template <typename UpdateReplicationInfoRequestT = Model::UpdateReplicationInfoRequest>
  void UpdateReplicationInfoAsync(const UpdateReplicationInfoRequestT& request, const UpdateReplicationInfoResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KafkaClient::UpdateReplicationInfo, request, handler, context);
  }
 
  virtual Model::UpdateSecurityOutcome UpdateSecurity(const Model::UpdateSecurityRequest& request) const;
 
  template <typename UpdateSecurityRequestT = Model::UpdateSecurityRequest>
  Model::UpdateSecurityOutcomeCallable UpdateSecurityCallable(const UpdateSecurityRequestT& request) const {
    return SubmitCallable(&KafkaClient::UpdateSecurity, request);
  }
 
  template <typename UpdateSecurityRequestT = Model::UpdateSecurityRequest>
  void UpdateSecurityAsync(const UpdateSecurityRequestT& request, const UpdateSecurityResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KafkaClient::UpdateSecurity, request, handler, context);
  }
 
  virtual Model::UpdateStorageOutcome UpdateStorage(const Model::UpdateStorageRequest& request) const;
 
  template <typename UpdateStorageRequestT = Model::UpdateStorageRequest>
  Model::UpdateStorageOutcomeCallable UpdateStorageCallable(const UpdateStorageRequestT& request) const {
    return SubmitCallable(&KafkaClient::UpdateStorage, request);
  }
 
  template <typename UpdateStorageRequestT = Model::UpdateStorageRequest>
  void UpdateStorageAsync(const UpdateStorageRequestT& request, const UpdateStorageResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KafkaClient::UpdateStorage, request, handler, context);
  }
 
  virtual Model::UpdateTopicOutcome UpdateTopic(const Model::UpdateTopicRequest& request) const;
 
  template <typename UpdateTopicRequestT = Model::UpdateTopicRequest>
  Model::UpdateTopicOutcomeCallable UpdateTopicCallable(const UpdateTopicRequestT& request) const {
    return SubmitCallable(&KafkaClient::UpdateTopic, request);
  }
 
  template <typename UpdateTopicRequestT = Model::UpdateTopicRequest>
  void UpdateTopicAsync(const UpdateTopicRequestT& request, const UpdateTopicResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&KafkaClient::UpdateTopic, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<KafkaEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<KafkaClient>;
  void init(const KafkaClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, KafkaError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  KafkaClientConfiguration m_clientConfiguration;
  std::shared_ptr<KafkaEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace Kafka
}  // namespace Aws