FirehoseClient.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/firehose/FirehosePaginationBase.h>
#include <aws/firehose/FirehoseServiceClientModel.h>
#include <aws/firehose/FirehoseWaiter.h>
#include <aws/firehose/Firehose_EXPORTS.h>
 
namespace Aws {
namespace Firehose {
class AWS_FIREHOSE_API FirehoseClient : public Aws::Client::AWSJsonClient,
                                        public Aws::Client::ClientWithAsyncTemplateMethods<FirehoseClient>,
                                        public FirehosePaginationBase<FirehoseClient>,
                                        public FirehoseWaiter<FirehoseClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef FirehoseClientConfiguration ClientConfigurationType;
  typedef FirehoseEndpointProvider EndpointProviderType;
 
  FirehoseClient(const Aws::Firehose::FirehoseClientConfiguration& clientConfiguration = Aws::Firehose::FirehoseClientConfiguration(),
                 std::shared_ptr<FirehoseEndpointProviderBase> endpointProvider = nullptr);
 
  FirehoseClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<FirehoseEndpointProviderBase> endpointProvider = nullptr,
                 const Aws::Firehose::FirehoseClientConfiguration& clientConfiguration = Aws::Firehose::FirehoseClientConfiguration());
 
  FirehoseClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                 std::shared_ptr<FirehoseEndpointProviderBase> endpointProvider = nullptr,
                 const Aws::Firehose::FirehoseClientConfiguration& clientConfiguration = Aws::Firehose::FirehoseClientConfiguration());
 
  /* Legacy constructors due deprecation */
  FirehoseClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  FirehoseClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  FirehoseClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                 const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~FirehoseClient();
 
  virtual Model::CreateDeliveryStreamOutcome CreateDeliveryStream(const Model::CreateDeliveryStreamRequest& request) const;
 
  template <typename CreateDeliveryStreamRequestT = Model::CreateDeliveryStreamRequest>
  Model::CreateDeliveryStreamOutcomeCallable CreateDeliveryStreamCallable(const CreateDeliveryStreamRequestT& request) const {
    return SubmitCallable(&FirehoseClient::CreateDeliveryStream, request);
  }
 
  template <typename CreateDeliveryStreamRequestT = Model::CreateDeliveryStreamRequest>
  void CreateDeliveryStreamAsync(const CreateDeliveryStreamRequestT& request, const CreateDeliveryStreamResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FirehoseClient::CreateDeliveryStream, request, handler, context);
  }
 
  virtual Model::DeleteDeliveryStreamOutcome DeleteDeliveryStream(const Model::DeleteDeliveryStreamRequest& request) const;
 
  template <typename DeleteDeliveryStreamRequestT = Model::DeleteDeliveryStreamRequest>
  Model::DeleteDeliveryStreamOutcomeCallable DeleteDeliveryStreamCallable(const DeleteDeliveryStreamRequestT& request) const {
    return SubmitCallable(&FirehoseClient::DeleteDeliveryStream, request);
  }
 
  template <typename DeleteDeliveryStreamRequestT = Model::DeleteDeliveryStreamRequest>
  void DeleteDeliveryStreamAsync(const DeleteDeliveryStreamRequestT& request, const DeleteDeliveryStreamResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FirehoseClient::DeleteDeliveryStream, request, handler, context);
  }
 
  virtual Model::DescribeDeliveryStreamOutcome DescribeDeliveryStream(const Model::DescribeDeliveryStreamRequest& request) const;
 
  template <typename DescribeDeliveryStreamRequestT = Model::DescribeDeliveryStreamRequest>
  Model::DescribeDeliveryStreamOutcomeCallable DescribeDeliveryStreamCallable(const DescribeDeliveryStreamRequestT& request) const {
    return SubmitCallable(&FirehoseClient::DescribeDeliveryStream, request);
  }
 
  template <typename DescribeDeliveryStreamRequestT = Model::DescribeDeliveryStreamRequest>
  void DescribeDeliveryStreamAsync(const DescribeDeliveryStreamRequestT& request,
                                   const DescribeDeliveryStreamResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FirehoseClient::DescribeDeliveryStream, request, handler, context);
  }
 
  virtual Model::ListDeliveryStreamsOutcome ListDeliveryStreams(const Model::ListDeliveryStreamsRequest& request = {}) const;
 
  template <typename ListDeliveryStreamsRequestT = Model::ListDeliveryStreamsRequest>
  Model::ListDeliveryStreamsOutcomeCallable ListDeliveryStreamsCallable(const ListDeliveryStreamsRequestT& request = {}) const {
    return SubmitCallable(&FirehoseClient::ListDeliveryStreams, request);
  }
 
  template <typename ListDeliveryStreamsRequestT = Model::ListDeliveryStreamsRequest>
  void ListDeliveryStreamsAsync(const ListDeliveryStreamsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const ListDeliveryStreamsRequestT& request = {}) const {
    return SubmitAsync(&FirehoseClient::ListDeliveryStreams, request, handler, context);
  }
 
  virtual Model::ListTagsForDeliveryStreamOutcome ListTagsForDeliveryStream(const Model::ListTagsForDeliveryStreamRequest& request) const;
 
  template <typename ListTagsForDeliveryStreamRequestT = Model::ListTagsForDeliveryStreamRequest>
  Model::ListTagsForDeliveryStreamOutcomeCallable ListTagsForDeliveryStreamCallable(
      const ListTagsForDeliveryStreamRequestT& request) const {
    return SubmitCallable(&FirehoseClient::ListTagsForDeliveryStream, request);
  }
 
  template <typename ListTagsForDeliveryStreamRequestT = Model::ListTagsForDeliveryStreamRequest>
  void ListTagsForDeliveryStreamAsync(const ListTagsForDeliveryStreamRequestT& request,
                                      const ListTagsForDeliveryStreamResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FirehoseClient::ListTagsForDeliveryStream, request, handler, context);
  }
 
  virtual Model::PutRecordOutcome PutRecord(const Model::PutRecordRequest& request) const;
 
  template <typename PutRecordRequestT = Model::PutRecordRequest>
  Model::PutRecordOutcomeCallable PutRecordCallable(const PutRecordRequestT& request) const {
    return SubmitCallable(&FirehoseClient::PutRecord, request);
  }
 
  template <typename PutRecordRequestT = Model::PutRecordRequest>
  void PutRecordAsync(const PutRecordRequestT& request, const PutRecordResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FirehoseClient::PutRecord, request, handler, context);
  }
 
  virtual Model::PutRecordBatchOutcome PutRecordBatch(const Model::PutRecordBatchRequest& request) const;
 
  template <typename PutRecordBatchRequestT = Model::PutRecordBatchRequest>
  Model::PutRecordBatchOutcomeCallable PutRecordBatchCallable(const PutRecordBatchRequestT& request) const {
    return SubmitCallable(&FirehoseClient::PutRecordBatch, request);
  }
 
  template <typename PutRecordBatchRequestT = Model::PutRecordBatchRequest>
  void PutRecordBatchAsync(const PutRecordBatchRequestT& request, const PutRecordBatchResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FirehoseClient::PutRecordBatch, request, handler, context);
  }
 
  virtual Model::StartDeliveryStreamEncryptionOutcome StartDeliveryStreamEncryption(
      const Model::StartDeliveryStreamEncryptionRequest& request) const;
 
  template <typename StartDeliveryStreamEncryptionRequestT = Model::StartDeliveryStreamEncryptionRequest>
  Model::StartDeliveryStreamEncryptionOutcomeCallable StartDeliveryStreamEncryptionCallable(
      const StartDeliveryStreamEncryptionRequestT& request) const {
    return SubmitCallable(&FirehoseClient::StartDeliveryStreamEncryption, request);
  }
 
  template <typename StartDeliveryStreamEncryptionRequestT = Model::StartDeliveryStreamEncryptionRequest>
  void StartDeliveryStreamEncryptionAsync(const StartDeliveryStreamEncryptionRequestT& request,
                                          const StartDeliveryStreamEncryptionResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FirehoseClient::StartDeliveryStreamEncryption, request, handler, context);
  }
 
  virtual Model::StopDeliveryStreamEncryptionOutcome StopDeliveryStreamEncryption(
      const Model::StopDeliveryStreamEncryptionRequest& request) const;
 
  template <typename StopDeliveryStreamEncryptionRequestT = Model::StopDeliveryStreamEncryptionRequest>
  Model::StopDeliveryStreamEncryptionOutcomeCallable StopDeliveryStreamEncryptionCallable(
      const StopDeliveryStreamEncryptionRequestT& request) const {
    return SubmitCallable(&FirehoseClient::StopDeliveryStreamEncryption, request);
  }
 
  template <typename StopDeliveryStreamEncryptionRequestT = Model::StopDeliveryStreamEncryptionRequest>
  void StopDeliveryStreamEncryptionAsync(const StopDeliveryStreamEncryptionRequestT& request,
                                         const StopDeliveryStreamEncryptionResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FirehoseClient::StopDeliveryStreamEncryption, request, handler, context);
  }
 
  virtual Model::TagDeliveryStreamOutcome TagDeliveryStream(const Model::TagDeliveryStreamRequest& request) const;
 
  template <typename TagDeliveryStreamRequestT = Model::TagDeliveryStreamRequest>
  Model::TagDeliveryStreamOutcomeCallable TagDeliveryStreamCallable(const TagDeliveryStreamRequestT& request) const {
    return SubmitCallable(&FirehoseClient::TagDeliveryStream, request);
  }
 
  template <typename TagDeliveryStreamRequestT = Model::TagDeliveryStreamRequest>
  void TagDeliveryStreamAsync(const TagDeliveryStreamRequestT& request, const TagDeliveryStreamResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FirehoseClient::TagDeliveryStream, request, handler, context);
  }
 
  virtual Model::UntagDeliveryStreamOutcome UntagDeliveryStream(const Model::UntagDeliveryStreamRequest& request) const;
 
  template <typename UntagDeliveryStreamRequestT = Model::UntagDeliveryStreamRequest>
  Model::UntagDeliveryStreamOutcomeCallable UntagDeliveryStreamCallable(const UntagDeliveryStreamRequestT& request) const {
    return SubmitCallable(&FirehoseClient::UntagDeliveryStream, request);
  }
 
  template <typename UntagDeliveryStreamRequestT = Model::UntagDeliveryStreamRequest>
  void UntagDeliveryStreamAsync(const UntagDeliveryStreamRequestT& request, const UntagDeliveryStreamResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FirehoseClient::UntagDeliveryStream, request, handler, context);
  }
 
  virtual Model::UpdateDestinationOutcome UpdateDestination(const Model::UpdateDestinationRequest& request) const;
 
  template <typename UpdateDestinationRequestT = Model::UpdateDestinationRequest>
  Model::UpdateDestinationOutcomeCallable UpdateDestinationCallable(const UpdateDestinationRequestT& request) const {
    return SubmitCallable(&FirehoseClient::UpdateDestination, request);
  }
 
  template <typename UpdateDestinationRequestT = Model::UpdateDestinationRequest>
  void UpdateDestinationAsync(const UpdateDestinationRequestT& request, const UpdateDestinationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&FirehoseClient::UpdateDestination, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<FirehoseEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<FirehoseClient>;
  void init(const FirehoseClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, FirehoseError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  FirehoseClientConfiguration m_clientConfiguration;
  std::shared_ptr<FirehoseEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace Firehose
}  // namespace Aws