FirehoseClient.h

 
#pragma once
#include <aws/firehose/Firehose_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/firehose/FirehoseServiceClientModel.h>
 
namespace Aws
{
namespace Firehose
{
  class AWS_FIREHOSE_API FirehoseClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<FirehoseEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<FirehoseClient>;
      void init(const FirehoseClientConfiguration& clientConfiguration);
 
      FirehoseClientConfiguration m_clientConfiguration;
      std::shared_ptr<FirehoseEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace Firehose
} // namespace Aws