KafkaConnectClient.h

 
#pragma once
#include <aws/kafkaconnect/KafkaConnect_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/kafkaconnect/KafkaConnectServiceClientModel.h>
 
namespace Aws
{
namespace KafkaConnect
{
  class AWS_KAFKACONNECT_API KafkaConnectClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<KafkaConnectClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef KafkaConnectClientConfiguration ClientConfigurationType;
      typedef KafkaConnectEndpointProvider EndpointProviderType;
 
        KafkaConnectClient(const Aws::KafkaConnect::KafkaConnectClientConfiguration& clientConfiguration = Aws::KafkaConnect::KafkaConnectClientConfiguration(),
                           std::shared_ptr<KafkaConnectEndpointProviderBase> endpointProvider = nullptr);
 
        KafkaConnectClient(const Aws::Auth::AWSCredentials& credentials,
                           std::shared_ptr<KafkaConnectEndpointProviderBase> endpointProvider = nullptr,
                           const Aws::KafkaConnect::KafkaConnectClientConfiguration& clientConfiguration = Aws::KafkaConnect::KafkaConnectClientConfiguration());
 
        KafkaConnectClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                           std::shared_ptr<KafkaConnectEndpointProviderBase> endpointProvider = nullptr,
                           const Aws::KafkaConnect::KafkaConnectClientConfiguration& clientConfiguration = Aws::KafkaConnect::KafkaConnectClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        KafkaConnectClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        KafkaConnectClient(const Aws::Auth::AWSCredentials& credentials,
                           const Aws::Client::ClientConfiguration& clientConfiguration);
 
        KafkaConnectClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                           const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~KafkaConnectClient();
 
        virtual Model::CreateConnectorOutcome CreateConnector(const Model::CreateConnectorRequest& request) const;
 
        template<typename CreateConnectorRequestT = Model::CreateConnectorRequest>
        Model::CreateConnectorOutcomeCallable CreateConnectorCallable(const CreateConnectorRequestT& request) const
        {
            return SubmitCallable(&KafkaConnectClient::CreateConnector, request);
        }
 
        template<typename CreateConnectorRequestT = Model::CreateConnectorRequest>
        void CreateConnectorAsync(const CreateConnectorRequestT& request, const CreateConnectorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&KafkaConnectClient::CreateConnector, request, handler, context);
        }
 
        virtual Model::CreateCustomPluginOutcome CreateCustomPlugin(const Model::CreateCustomPluginRequest& request) const;
 
        template<typename CreateCustomPluginRequestT = Model::CreateCustomPluginRequest>
        Model::CreateCustomPluginOutcomeCallable CreateCustomPluginCallable(const CreateCustomPluginRequestT& request) const
        {
            return SubmitCallable(&KafkaConnectClient::CreateCustomPlugin, request);
        }
 
        template<typename CreateCustomPluginRequestT = Model::CreateCustomPluginRequest>
        void CreateCustomPluginAsync(const CreateCustomPluginRequestT& request, const CreateCustomPluginResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&KafkaConnectClient::CreateCustomPlugin, request, handler, context);
        }
 
        virtual Model::CreateWorkerConfigurationOutcome CreateWorkerConfiguration(const Model::CreateWorkerConfigurationRequest& request) const;
 
        template<typename CreateWorkerConfigurationRequestT = Model::CreateWorkerConfigurationRequest>
        Model::CreateWorkerConfigurationOutcomeCallable CreateWorkerConfigurationCallable(const CreateWorkerConfigurationRequestT& request) const
        {
            return SubmitCallable(&KafkaConnectClient::CreateWorkerConfiguration, request);
        }
 
        template<typename CreateWorkerConfigurationRequestT = Model::CreateWorkerConfigurationRequest>
        void CreateWorkerConfigurationAsync(const CreateWorkerConfigurationRequestT& request, const CreateWorkerConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&KafkaConnectClient::CreateWorkerConfiguration, request, handler, context);
        }
 
        virtual Model::DeleteConnectorOutcome DeleteConnector(const Model::DeleteConnectorRequest& request) const;
 
        template<typename DeleteConnectorRequestT = Model::DeleteConnectorRequest>
        Model::DeleteConnectorOutcomeCallable DeleteConnectorCallable(const DeleteConnectorRequestT& request) const
        {
            return SubmitCallable(&KafkaConnectClient::DeleteConnector, request);
        }
 
        template<typename DeleteConnectorRequestT = Model::DeleteConnectorRequest>
        void DeleteConnectorAsync(const DeleteConnectorRequestT& request, const DeleteConnectorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&KafkaConnectClient::DeleteConnector, request, handler, context);
        }
 
        virtual Model::DeleteCustomPluginOutcome DeleteCustomPlugin(const Model::DeleteCustomPluginRequest& request) const;
 
        template<typename DeleteCustomPluginRequestT = Model::DeleteCustomPluginRequest>
        Model::DeleteCustomPluginOutcomeCallable DeleteCustomPluginCallable(const DeleteCustomPluginRequestT& request) const
        {
            return SubmitCallable(&KafkaConnectClient::DeleteCustomPlugin, request);
        }
 
        template<typename DeleteCustomPluginRequestT = Model::DeleteCustomPluginRequest>
        void DeleteCustomPluginAsync(const DeleteCustomPluginRequestT& request, const DeleteCustomPluginResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&KafkaConnectClient::DeleteCustomPlugin, request, handler, context);
        }
 
        virtual Model::DeleteWorkerConfigurationOutcome DeleteWorkerConfiguration(const Model::DeleteWorkerConfigurationRequest& request) const;
 
        template<typename DeleteWorkerConfigurationRequestT = Model::DeleteWorkerConfigurationRequest>
        Model::DeleteWorkerConfigurationOutcomeCallable DeleteWorkerConfigurationCallable(const DeleteWorkerConfigurationRequestT& request) const
        {
            return SubmitCallable(&KafkaConnectClient::DeleteWorkerConfiguration, request);
        }
 
        template<typename DeleteWorkerConfigurationRequestT = Model::DeleteWorkerConfigurationRequest>
        void DeleteWorkerConfigurationAsync(const DeleteWorkerConfigurationRequestT& request, const DeleteWorkerConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&KafkaConnectClient::DeleteWorkerConfiguration, request, handler, context);
        }
 
        virtual Model::DescribeConnectorOutcome DescribeConnector(const Model::DescribeConnectorRequest& request) const;
 
        template<typename DescribeConnectorRequestT = Model::DescribeConnectorRequest>
        Model::DescribeConnectorOutcomeCallable DescribeConnectorCallable(const DescribeConnectorRequestT& request) const
        {
            return SubmitCallable(&KafkaConnectClient::DescribeConnector, request);
        }
 
        template<typename DescribeConnectorRequestT = Model::DescribeConnectorRequest>
        void DescribeConnectorAsync(const DescribeConnectorRequestT& request, const DescribeConnectorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&KafkaConnectClient::DescribeConnector, request, handler, context);
        }
 
        virtual Model::DescribeConnectorOperationOutcome DescribeConnectorOperation(const Model::DescribeConnectorOperationRequest& request) const;
 
        template<typename DescribeConnectorOperationRequestT = Model::DescribeConnectorOperationRequest>
        Model::DescribeConnectorOperationOutcomeCallable DescribeConnectorOperationCallable(const DescribeConnectorOperationRequestT& request) const
        {
            return SubmitCallable(&KafkaConnectClient::DescribeConnectorOperation, request);
        }
 
        template<typename DescribeConnectorOperationRequestT = Model::DescribeConnectorOperationRequest>
        void DescribeConnectorOperationAsync(const DescribeConnectorOperationRequestT& request, const DescribeConnectorOperationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&KafkaConnectClient::DescribeConnectorOperation, request, handler, context);
        }
 
        virtual Model::DescribeCustomPluginOutcome DescribeCustomPlugin(const Model::DescribeCustomPluginRequest& request) const;
 
        template<typename DescribeCustomPluginRequestT = Model::DescribeCustomPluginRequest>
        Model::DescribeCustomPluginOutcomeCallable DescribeCustomPluginCallable(const DescribeCustomPluginRequestT& request) const
        {
            return SubmitCallable(&KafkaConnectClient::DescribeCustomPlugin, request);
        }
 
        template<typename DescribeCustomPluginRequestT = Model::DescribeCustomPluginRequest>
        void DescribeCustomPluginAsync(const DescribeCustomPluginRequestT& request, const DescribeCustomPluginResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&KafkaConnectClient::DescribeCustomPlugin, request, handler, context);
        }
 
        virtual Model::DescribeWorkerConfigurationOutcome DescribeWorkerConfiguration(const Model::DescribeWorkerConfigurationRequest& request) const;
 
        template<typename DescribeWorkerConfigurationRequestT = Model::DescribeWorkerConfigurationRequest>
        Model::DescribeWorkerConfigurationOutcomeCallable DescribeWorkerConfigurationCallable(const DescribeWorkerConfigurationRequestT& request) const
        {
            return SubmitCallable(&KafkaConnectClient::DescribeWorkerConfiguration, request);
        }
 
        template<typename DescribeWorkerConfigurationRequestT = Model::DescribeWorkerConfigurationRequest>
        void DescribeWorkerConfigurationAsync(const DescribeWorkerConfigurationRequestT& request, const DescribeWorkerConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&KafkaConnectClient::DescribeWorkerConfiguration, request, handler, context);
        }
 
        virtual Model::ListConnectorOperationsOutcome ListConnectorOperations(const Model::ListConnectorOperationsRequest& request) const;
 
        template<typename ListConnectorOperationsRequestT = Model::ListConnectorOperationsRequest>
        Model::ListConnectorOperationsOutcomeCallable ListConnectorOperationsCallable(const ListConnectorOperationsRequestT& request) const
        {
            return SubmitCallable(&KafkaConnectClient::ListConnectorOperations, request);
        }
 
        template<typename ListConnectorOperationsRequestT = Model::ListConnectorOperationsRequest>
        void ListConnectorOperationsAsync(const ListConnectorOperationsRequestT& request, const ListConnectorOperationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&KafkaConnectClient::ListConnectorOperations, request, handler, context);
        }
 
        virtual Model::ListConnectorsOutcome ListConnectors(const Model::ListConnectorsRequest& request = {}) const;
 
        template<typename ListConnectorsRequestT = Model::ListConnectorsRequest>
        Model::ListConnectorsOutcomeCallable ListConnectorsCallable(const ListConnectorsRequestT& request = {}) const
        {
            return SubmitCallable(&KafkaConnectClient::ListConnectors, request);
        }
 
        template<typename ListConnectorsRequestT = Model::ListConnectorsRequest>
        void ListConnectorsAsync(const ListConnectorsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListConnectorsRequestT& request = {}) const
        {
            return SubmitAsync(&KafkaConnectClient::ListConnectors, request, handler, context);
        }
 
        virtual Model::ListCustomPluginsOutcome ListCustomPlugins(const Model::ListCustomPluginsRequest& request = {}) const;
 
        template<typename ListCustomPluginsRequestT = Model::ListCustomPluginsRequest>
        Model::ListCustomPluginsOutcomeCallable ListCustomPluginsCallable(const ListCustomPluginsRequestT& request = {}) const
        {
            return SubmitCallable(&KafkaConnectClient::ListCustomPlugins, request);
        }
 
        template<typename ListCustomPluginsRequestT = Model::ListCustomPluginsRequest>
        void ListCustomPluginsAsync(const ListCustomPluginsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListCustomPluginsRequestT& request = {}) const
        {
            return SubmitAsync(&KafkaConnectClient::ListCustomPlugins, 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(&KafkaConnectClient::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(&KafkaConnectClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::ListWorkerConfigurationsOutcome ListWorkerConfigurations(const Model::ListWorkerConfigurationsRequest& request = {}) const;
 
        template<typename ListWorkerConfigurationsRequestT = Model::ListWorkerConfigurationsRequest>
        Model::ListWorkerConfigurationsOutcomeCallable ListWorkerConfigurationsCallable(const ListWorkerConfigurationsRequestT& request = {}) const
        {
            return SubmitCallable(&KafkaConnectClient::ListWorkerConfigurations, request);
        }
 
        template<typename ListWorkerConfigurationsRequestT = Model::ListWorkerConfigurationsRequest>
        void ListWorkerConfigurationsAsync(const ListWorkerConfigurationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListWorkerConfigurationsRequestT& request = {}) const
        {
            return SubmitAsync(&KafkaConnectClient::ListWorkerConfigurations, 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(&KafkaConnectClient::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(&KafkaConnectClient::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(&KafkaConnectClient::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(&KafkaConnectClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateConnectorOutcome UpdateConnector(const Model::UpdateConnectorRequest& request) const;
 
        template<typename UpdateConnectorRequestT = Model::UpdateConnectorRequest>
        Model::UpdateConnectorOutcomeCallable UpdateConnectorCallable(const UpdateConnectorRequestT& request) const
        {
            return SubmitCallable(&KafkaConnectClient::UpdateConnector, request);
        }
 
        template<typename UpdateConnectorRequestT = Model::UpdateConnectorRequest>
        void UpdateConnectorAsync(const UpdateConnectorRequestT& request, const UpdateConnectorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&KafkaConnectClient::UpdateConnector, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<KafkaConnectEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<KafkaConnectClient>;
      void init(const KafkaConnectClientConfiguration& clientConfiguration);
 
      KafkaConnectClientConfiguration m_clientConfiguration;
      std::shared_ptr<KafkaConnectEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace KafkaConnect
} // namespace Aws