KafkaClient.h

 
#pragma once
#include <aws/kafka/Kafka_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/kafka/KafkaServiceClientModel.h>
 
namespace Aws
{
namespace Kafka
{
  class AWS_KAFKA_API KafkaClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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::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::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::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::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::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::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::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::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::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::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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<KafkaEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<KafkaClient>;
      void init(const KafkaClientConfiguration& clientConfiguration);
 
      KafkaClientConfiguration m_clientConfiguration;
      std::shared_ptr<KafkaEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace Kafka
} // namespace Aws