QLDBClient.h

 
#pragma once
#include <aws/qldb/QLDB_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/qldb/QLDBServiceClientModel.h>
 
namespace Aws
{
namespace QLDB
{
  class AWS_QLDB_API QLDBClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<QLDBClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef QLDBClientConfiguration ClientConfigurationType;
      typedef QLDBEndpointProvider EndpointProviderType;
 
        QLDBClient(const Aws::QLDB::QLDBClientConfiguration& clientConfiguration = Aws::QLDB::QLDBClientConfiguration(),
                   std::shared_ptr<QLDBEndpointProviderBase> endpointProvider = nullptr);
 
        QLDBClient(const Aws::Auth::AWSCredentials& credentials,
                   std::shared_ptr<QLDBEndpointProviderBase> endpointProvider = nullptr,
                   const Aws::QLDB::QLDBClientConfiguration& clientConfiguration = Aws::QLDB::QLDBClientConfiguration());
 
        QLDBClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                   std::shared_ptr<QLDBEndpointProviderBase> endpointProvider = nullptr,
                   const Aws::QLDB::QLDBClientConfiguration& clientConfiguration = Aws::QLDB::QLDBClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        QLDBClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        QLDBClient(const Aws::Auth::AWSCredentials& credentials,
                   const Aws::Client::ClientConfiguration& clientConfiguration);
 
        QLDBClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                   const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~QLDBClient();
 
        virtual Model::CancelJournalKinesisStreamOutcome CancelJournalKinesisStream(const Model::CancelJournalKinesisStreamRequest& request) const;
 
        template<typename CancelJournalKinesisStreamRequestT = Model::CancelJournalKinesisStreamRequest>
        Model::CancelJournalKinesisStreamOutcomeCallable CancelJournalKinesisStreamCallable(const CancelJournalKinesisStreamRequestT& request) const
        {
            return SubmitCallable(&QLDBClient::CancelJournalKinesisStream, request);
        }
 
        template<typename CancelJournalKinesisStreamRequestT = Model::CancelJournalKinesisStreamRequest>
        void CancelJournalKinesisStreamAsync(const CancelJournalKinesisStreamRequestT& request, const CancelJournalKinesisStreamResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QLDBClient::CancelJournalKinesisStream, request, handler, context);
        }
 
        virtual Model::CreateLedgerOutcome CreateLedger(const Model::CreateLedgerRequest& request) const;
 
        template<typename CreateLedgerRequestT = Model::CreateLedgerRequest>
        Model::CreateLedgerOutcomeCallable CreateLedgerCallable(const CreateLedgerRequestT& request) const
        {
            return SubmitCallable(&QLDBClient::CreateLedger, request);
        }
 
        template<typename CreateLedgerRequestT = Model::CreateLedgerRequest>
        void CreateLedgerAsync(const CreateLedgerRequestT& request, const CreateLedgerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QLDBClient::CreateLedger, request, handler, context);
        }
 
        virtual Model::DeleteLedgerOutcome DeleteLedger(const Model::DeleteLedgerRequest& request) const;
 
        template<typename DeleteLedgerRequestT = Model::DeleteLedgerRequest>
        Model::DeleteLedgerOutcomeCallable DeleteLedgerCallable(const DeleteLedgerRequestT& request) const
        {
            return SubmitCallable(&QLDBClient::DeleteLedger, request);
        }
 
        template<typename DeleteLedgerRequestT = Model::DeleteLedgerRequest>
        void DeleteLedgerAsync(const DeleteLedgerRequestT& request, const DeleteLedgerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QLDBClient::DeleteLedger, request, handler, context);
        }
 
        virtual Model::DescribeJournalKinesisStreamOutcome DescribeJournalKinesisStream(const Model::DescribeJournalKinesisStreamRequest& request) const;
 
        template<typename DescribeJournalKinesisStreamRequestT = Model::DescribeJournalKinesisStreamRequest>
        Model::DescribeJournalKinesisStreamOutcomeCallable DescribeJournalKinesisStreamCallable(const DescribeJournalKinesisStreamRequestT& request) const
        {
            return SubmitCallable(&QLDBClient::DescribeJournalKinesisStream, request);
        }
 
        template<typename DescribeJournalKinesisStreamRequestT = Model::DescribeJournalKinesisStreamRequest>
        void DescribeJournalKinesisStreamAsync(const DescribeJournalKinesisStreamRequestT& request, const DescribeJournalKinesisStreamResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QLDBClient::DescribeJournalKinesisStream, request, handler, context);
        }
 
        virtual Model::DescribeJournalS3ExportOutcome DescribeJournalS3Export(const Model::DescribeJournalS3ExportRequest& request) const;
 
        template<typename DescribeJournalS3ExportRequestT = Model::DescribeJournalS3ExportRequest>
        Model::DescribeJournalS3ExportOutcomeCallable DescribeJournalS3ExportCallable(const DescribeJournalS3ExportRequestT& request) const
        {
            return SubmitCallable(&QLDBClient::DescribeJournalS3Export, request);
        }
 
        template<typename DescribeJournalS3ExportRequestT = Model::DescribeJournalS3ExportRequest>
        void DescribeJournalS3ExportAsync(const DescribeJournalS3ExportRequestT& request, const DescribeJournalS3ExportResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QLDBClient::DescribeJournalS3Export, request, handler, context);
        }
 
        virtual Model::DescribeLedgerOutcome DescribeLedger(const Model::DescribeLedgerRequest& request) const;
 
        template<typename DescribeLedgerRequestT = Model::DescribeLedgerRequest>
        Model::DescribeLedgerOutcomeCallable DescribeLedgerCallable(const DescribeLedgerRequestT& request) const
        {
            return SubmitCallable(&QLDBClient::DescribeLedger, request);
        }
 
        template<typename DescribeLedgerRequestT = Model::DescribeLedgerRequest>
        void DescribeLedgerAsync(const DescribeLedgerRequestT& request, const DescribeLedgerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QLDBClient::DescribeLedger, request, handler, context);
        }
 
        virtual Model::ExportJournalToS3Outcome ExportJournalToS3(const Model::ExportJournalToS3Request& request) const;
 
        template<typename ExportJournalToS3RequestT = Model::ExportJournalToS3Request>
        Model::ExportJournalToS3OutcomeCallable ExportJournalToS3Callable(const ExportJournalToS3RequestT& request) const
        {
            return SubmitCallable(&QLDBClient::ExportJournalToS3, request);
        }
 
        template<typename ExportJournalToS3RequestT = Model::ExportJournalToS3Request>
        void ExportJournalToS3Async(const ExportJournalToS3RequestT& request, const ExportJournalToS3ResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QLDBClient::ExportJournalToS3, request, handler, context);
        }
 
        virtual Model::GetBlockOutcome GetBlock(const Model::GetBlockRequest& request) const;
 
        template<typename GetBlockRequestT = Model::GetBlockRequest>
        Model::GetBlockOutcomeCallable GetBlockCallable(const GetBlockRequestT& request) const
        {
            return SubmitCallable(&QLDBClient::GetBlock, request);
        }
 
        template<typename GetBlockRequestT = Model::GetBlockRequest>
        void GetBlockAsync(const GetBlockRequestT& request, const GetBlockResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QLDBClient::GetBlock, request, handler, context);
        }
 
        virtual Model::GetDigestOutcome GetDigest(const Model::GetDigestRequest& request) const;
 
        template<typename GetDigestRequestT = Model::GetDigestRequest>
        Model::GetDigestOutcomeCallable GetDigestCallable(const GetDigestRequestT& request) const
        {
            return SubmitCallable(&QLDBClient::GetDigest, request);
        }
 
        template<typename GetDigestRequestT = Model::GetDigestRequest>
        void GetDigestAsync(const GetDigestRequestT& request, const GetDigestResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QLDBClient::GetDigest, request, handler, context);
        }
 
        virtual Model::GetRevisionOutcome GetRevision(const Model::GetRevisionRequest& request) const;
 
        template<typename GetRevisionRequestT = Model::GetRevisionRequest>
        Model::GetRevisionOutcomeCallable GetRevisionCallable(const GetRevisionRequestT& request) const
        {
            return SubmitCallable(&QLDBClient::GetRevision, request);
        }
 
        template<typename GetRevisionRequestT = Model::GetRevisionRequest>
        void GetRevisionAsync(const GetRevisionRequestT& request, const GetRevisionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QLDBClient::GetRevision, request, handler, context);
        }
 
        virtual Model::ListJournalKinesisStreamsForLedgerOutcome ListJournalKinesisStreamsForLedger(const Model::ListJournalKinesisStreamsForLedgerRequest& request) const;
 
        template<typename ListJournalKinesisStreamsForLedgerRequestT = Model::ListJournalKinesisStreamsForLedgerRequest>
        Model::ListJournalKinesisStreamsForLedgerOutcomeCallable ListJournalKinesisStreamsForLedgerCallable(const ListJournalKinesisStreamsForLedgerRequestT& request) const
        {
            return SubmitCallable(&QLDBClient::ListJournalKinesisStreamsForLedger, request);
        }
 
        template<typename ListJournalKinesisStreamsForLedgerRequestT = Model::ListJournalKinesisStreamsForLedgerRequest>
        void ListJournalKinesisStreamsForLedgerAsync(const ListJournalKinesisStreamsForLedgerRequestT& request, const ListJournalKinesisStreamsForLedgerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QLDBClient::ListJournalKinesisStreamsForLedger, request, handler, context);
        }
 
        virtual Model::ListJournalS3ExportsOutcome ListJournalS3Exports(const Model::ListJournalS3ExportsRequest& request = {}) const;
 
        template<typename ListJournalS3ExportsRequestT = Model::ListJournalS3ExportsRequest>
        Model::ListJournalS3ExportsOutcomeCallable ListJournalS3ExportsCallable(const ListJournalS3ExportsRequestT& request = {}) const
        {
            return SubmitCallable(&QLDBClient::ListJournalS3Exports, request);
        }
 
        template<typename ListJournalS3ExportsRequestT = Model::ListJournalS3ExportsRequest>
        void ListJournalS3ExportsAsync(const ListJournalS3ExportsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListJournalS3ExportsRequestT& request = {}) const
        {
            return SubmitAsync(&QLDBClient::ListJournalS3Exports, request, handler, context);
        }
 
        virtual Model::ListJournalS3ExportsForLedgerOutcome ListJournalS3ExportsForLedger(const Model::ListJournalS3ExportsForLedgerRequest& request) const;
 
        template<typename ListJournalS3ExportsForLedgerRequestT = Model::ListJournalS3ExportsForLedgerRequest>
        Model::ListJournalS3ExportsForLedgerOutcomeCallable ListJournalS3ExportsForLedgerCallable(const ListJournalS3ExportsForLedgerRequestT& request) const
        {
            return SubmitCallable(&QLDBClient::ListJournalS3ExportsForLedger, request);
        }
 
        template<typename ListJournalS3ExportsForLedgerRequestT = Model::ListJournalS3ExportsForLedgerRequest>
        void ListJournalS3ExportsForLedgerAsync(const ListJournalS3ExportsForLedgerRequestT& request, const ListJournalS3ExportsForLedgerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QLDBClient::ListJournalS3ExportsForLedger, request, handler, context);
        }
 
        virtual Model::ListLedgersOutcome ListLedgers(const Model::ListLedgersRequest& request = {}) const;
 
        template<typename ListLedgersRequestT = Model::ListLedgersRequest>
        Model::ListLedgersOutcomeCallable ListLedgersCallable(const ListLedgersRequestT& request = {}) const
        {
            return SubmitCallable(&QLDBClient::ListLedgers, request);
        }
 
        template<typename ListLedgersRequestT = Model::ListLedgersRequest>
        void ListLedgersAsync(const ListLedgersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListLedgersRequestT& request = {}) const
        {
            return SubmitAsync(&QLDBClient::ListLedgers, 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(&QLDBClient::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(&QLDBClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::StreamJournalToKinesisOutcome StreamJournalToKinesis(const Model::StreamJournalToKinesisRequest& request) const;
 
        template<typename StreamJournalToKinesisRequestT = Model::StreamJournalToKinesisRequest>
        Model::StreamJournalToKinesisOutcomeCallable StreamJournalToKinesisCallable(const StreamJournalToKinesisRequestT& request) const
        {
            return SubmitCallable(&QLDBClient::StreamJournalToKinesis, request);
        }
 
        template<typename StreamJournalToKinesisRequestT = Model::StreamJournalToKinesisRequest>
        void StreamJournalToKinesisAsync(const StreamJournalToKinesisRequestT& request, const StreamJournalToKinesisResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QLDBClient::StreamJournalToKinesis, 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(&QLDBClient::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(&QLDBClient::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(&QLDBClient::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(&QLDBClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateLedgerOutcome UpdateLedger(const Model::UpdateLedgerRequest& request) const;
 
        template<typename UpdateLedgerRequestT = Model::UpdateLedgerRequest>
        Model::UpdateLedgerOutcomeCallable UpdateLedgerCallable(const UpdateLedgerRequestT& request) const
        {
            return SubmitCallable(&QLDBClient::UpdateLedger, request);
        }
 
        template<typename UpdateLedgerRequestT = Model::UpdateLedgerRequest>
        void UpdateLedgerAsync(const UpdateLedgerRequestT& request, const UpdateLedgerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QLDBClient::UpdateLedger, request, handler, context);
        }
 
        virtual Model::UpdateLedgerPermissionsModeOutcome UpdateLedgerPermissionsMode(const Model::UpdateLedgerPermissionsModeRequest& request) const;
 
        template<typename UpdateLedgerPermissionsModeRequestT = Model::UpdateLedgerPermissionsModeRequest>
        Model::UpdateLedgerPermissionsModeOutcomeCallable UpdateLedgerPermissionsModeCallable(const UpdateLedgerPermissionsModeRequestT& request) const
        {
            return SubmitCallable(&QLDBClient::UpdateLedgerPermissionsMode, request);
        }
 
        template<typename UpdateLedgerPermissionsModeRequestT = Model::UpdateLedgerPermissionsModeRequest>
        void UpdateLedgerPermissionsModeAsync(const UpdateLedgerPermissionsModeRequestT& request, const UpdateLedgerPermissionsModeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&QLDBClient::UpdateLedgerPermissionsMode, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<QLDBEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<QLDBClient>;
      void init(const QLDBClientConfiguration& clientConfiguration);
 
      QLDBClientConfiguration m_clientConfiguration;
      std::shared_ptr<QLDBEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace QLDB
} // namespace Aws