KafkaConnectClient.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/kafkaconnect/KafkaConnectPaginationBase.h>
#include <aws/kafkaconnect/KafkaConnectServiceClientModel.h>
#include <aws/kafkaconnect/KafkaConnectWaiter.h>
#include <aws/kafkaconnect/KafkaConnect_EXPORTS.h>
 
namespace Aws {
namespace KafkaConnect {
class AWS_KAFKACONNECT_API KafkaConnectClient : public Aws::Client::AWSJsonClient,
                                                public Aws::Client::ClientWithAsyncTemplateMethods<KafkaConnectClient>,
                                                public KafkaConnectPaginationBase<KafkaConnectClient>,
                                                public KafkaConnectWaiter<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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<KafkaConnectEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<KafkaConnectClient>;
  void init(const KafkaConnectClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, KafkaConnectError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  KafkaConnectClientConfiguration m_clientConfiguration;
  std::shared_ptr<KafkaConnectEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace KafkaConnect
}  // namespace Aws