TimestreamInfluxDBClient.h

 
#pragma once
#include <aws/timestream-influxdb/TimestreamInfluxDB_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/timestream-influxdb/TimestreamInfluxDBServiceClientModel.h>
 
namespace Aws
{
namespace TimestreamInfluxDB
{
  class AWS_TIMESTREAMINFLUXDB_API TimestreamInfluxDBClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<TimestreamInfluxDBClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef TimestreamInfluxDBClientConfiguration ClientConfigurationType;
      typedef TimestreamInfluxDBEndpointProvider EndpointProviderType;
 
        TimestreamInfluxDBClient(const Aws::TimestreamInfluxDB::TimestreamInfluxDBClientConfiguration& clientConfiguration = Aws::TimestreamInfluxDB::TimestreamInfluxDBClientConfiguration(),
                                 std::shared_ptr<TimestreamInfluxDBEndpointProviderBase> endpointProvider = nullptr);
 
        TimestreamInfluxDBClient(const Aws::Auth::AWSCredentials& credentials,
                                 std::shared_ptr<TimestreamInfluxDBEndpointProviderBase> endpointProvider = nullptr,
                                 const Aws::TimestreamInfluxDB::TimestreamInfluxDBClientConfiguration& clientConfiguration = Aws::TimestreamInfluxDB::TimestreamInfluxDBClientConfiguration());
 
        TimestreamInfluxDBClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                                 std::shared_ptr<TimestreamInfluxDBEndpointProviderBase> endpointProvider = nullptr,
                                 const Aws::TimestreamInfluxDB::TimestreamInfluxDBClientConfiguration& clientConfiguration = Aws::TimestreamInfluxDB::TimestreamInfluxDBClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        TimestreamInfluxDBClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        TimestreamInfluxDBClient(const Aws::Auth::AWSCredentials& credentials,
                                 const Aws::Client::ClientConfiguration& clientConfiguration);
 
        TimestreamInfluxDBClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                                 const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~TimestreamInfluxDBClient();
 
        virtual Model::CreateDbClusterOutcome CreateDbCluster(const Model::CreateDbClusterRequest& request) const;
 
        template<typename CreateDbClusterRequestT = Model::CreateDbClusterRequest>
        Model::CreateDbClusterOutcomeCallable CreateDbClusterCallable(const CreateDbClusterRequestT& request) const
        {
            return SubmitCallable(&TimestreamInfluxDBClient::CreateDbCluster, request);
        }
 
        template<typename CreateDbClusterRequestT = Model::CreateDbClusterRequest>
        void CreateDbClusterAsync(const CreateDbClusterRequestT& request, const CreateDbClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TimestreamInfluxDBClient::CreateDbCluster, request, handler, context);
        }
 
        virtual Model::CreateDbInstanceOutcome CreateDbInstance(const Model::CreateDbInstanceRequest& request) const;
 
        template<typename CreateDbInstanceRequestT = Model::CreateDbInstanceRequest>
        Model::CreateDbInstanceOutcomeCallable CreateDbInstanceCallable(const CreateDbInstanceRequestT& request) const
        {
            return SubmitCallable(&TimestreamInfluxDBClient::CreateDbInstance, request);
        }
 
        template<typename CreateDbInstanceRequestT = Model::CreateDbInstanceRequest>
        void CreateDbInstanceAsync(const CreateDbInstanceRequestT& request, const CreateDbInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TimestreamInfluxDBClient::CreateDbInstance, request, handler, context);
        }
 
        virtual Model::CreateDbParameterGroupOutcome CreateDbParameterGroup(const Model::CreateDbParameterGroupRequest& request) const;
 
        template<typename CreateDbParameterGroupRequestT = Model::CreateDbParameterGroupRequest>
        Model::CreateDbParameterGroupOutcomeCallable CreateDbParameterGroupCallable(const CreateDbParameterGroupRequestT& request) const
        {
            return SubmitCallable(&TimestreamInfluxDBClient::CreateDbParameterGroup, request);
        }
 
        template<typename CreateDbParameterGroupRequestT = Model::CreateDbParameterGroupRequest>
        void CreateDbParameterGroupAsync(const CreateDbParameterGroupRequestT& request, const CreateDbParameterGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TimestreamInfluxDBClient::CreateDbParameterGroup, request, handler, context);
        }
 
        virtual Model::DeleteDbClusterOutcome DeleteDbCluster(const Model::DeleteDbClusterRequest& request) const;
 
        template<typename DeleteDbClusterRequestT = Model::DeleteDbClusterRequest>
        Model::DeleteDbClusterOutcomeCallable DeleteDbClusterCallable(const DeleteDbClusterRequestT& request) const
        {
            return SubmitCallable(&TimestreamInfluxDBClient::DeleteDbCluster, request);
        }
 
        template<typename DeleteDbClusterRequestT = Model::DeleteDbClusterRequest>
        void DeleteDbClusterAsync(const DeleteDbClusterRequestT& request, const DeleteDbClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TimestreamInfluxDBClient::DeleteDbCluster, request, handler, context);
        }
 
        virtual Model::DeleteDbInstanceOutcome DeleteDbInstance(const Model::DeleteDbInstanceRequest& request) const;
 
        template<typename DeleteDbInstanceRequestT = Model::DeleteDbInstanceRequest>
        Model::DeleteDbInstanceOutcomeCallable DeleteDbInstanceCallable(const DeleteDbInstanceRequestT& request) const
        {
            return SubmitCallable(&TimestreamInfluxDBClient::DeleteDbInstance, request);
        }
 
        template<typename DeleteDbInstanceRequestT = Model::DeleteDbInstanceRequest>
        void DeleteDbInstanceAsync(const DeleteDbInstanceRequestT& request, const DeleteDbInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TimestreamInfluxDBClient::DeleteDbInstance, request, handler, context);
        }
 
        virtual Model::GetDbClusterOutcome GetDbCluster(const Model::GetDbClusterRequest& request) const;
 
        template<typename GetDbClusterRequestT = Model::GetDbClusterRequest>
        Model::GetDbClusterOutcomeCallable GetDbClusterCallable(const GetDbClusterRequestT& request) const
        {
            return SubmitCallable(&TimestreamInfluxDBClient::GetDbCluster, request);
        }
 
        template<typename GetDbClusterRequestT = Model::GetDbClusterRequest>
        void GetDbClusterAsync(const GetDbClusterRequestT& request, const GetDbClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TimestreamInfluxDBClient::GetDbCluster, request, handler, context);
        }
 
        virtual Model::GetDbInstanceOutcome GetDbInstance(const Model::GetDbInstanceRequest& request) const;
 
        template<typename GetDbInstanceRequestT = Model::GetDbInstanceRequest>
        Model::GetDbInstanceOutcomeCallable GetDbInstanceCallable(const GetDbInstanceRequestT& request) const
        {
            return SubmitCallable(&TimestreamInfluxDBClient::GetDbInstance, request);
        }
 
        template<typename GetDbInstanceRequestT = Model::GetDbInstanceRequest>
        void GetDbInstanceAsync(const GetDbInstanceRequestT& request, const GetDbInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TimestreamInfluxDBClient::GetDbInstance, request, handler, context);
        }
 
        virtual Model::GetDbParameterGroupOutcome GetDbParameterGroup(const Model::GetDbParameterGroupRequest& request) const;
 
        template<typename GetDbParameterGroupRequestT = Model::GetDbParameterGroupRequest>
        Model::GetDbParameterGroupOutcomeCallable GetDbParameterGroupCallable(const GetDbParameterGroupRequestT& request) const
        {
            return SubmitCallable(&TimestreamInfluxDBClient::GetDbParameterGroup, request);
        }
 
        template<typename GetDbParameterGroupRequestT = Model::GetDbParameterGroupRequest>
        void GetDbParameterGroupAsync(const GetDbParameterGroupRequestT& request, const GetDbParameterGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TimestreamInfluxDBClient::GetDbParameterGroup, request, handler, context);
        }
 
        virtual Model::ListDbClustersOutcome ListDbClusters(const Model::ListDbClustersRequest& request = {}) const;
 
        template<typename ListDbClustersRequestT = Model::ListDbClustersRequest>
        Model::ListDbClustersOutcomeCallable ListDbClustersCallable(const ListDbClustersRequestT& request = {}) const
        {
            return SubmitCallable(&TimestreamInfluxDBClient::ListDbClusters, request);
        }
 
        template<typename ListDbClustersRequestT = Model::ListDbClustersRequest>
        void ListDbClustersAsync(const ListDbClustersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListDbClustersRequestT& request = {}) const
        {
            return SubmitAsync(&TimestreamInfluxDBClient::ListDbClusters, request, handler, context);
        }
 
        virtual Model::ListDbInstancesOutcome ListDbInstances(const Model::ListDbInstancesRequest& request = {}) const;
 
        template<typename ListDbInstancesRequestT = Model::ListDbInstancesRequest>
        Model::ListDbInstancesOutcomeCallable ListDbInstancesCallable(const ListDbInstancesRequestT& request = {}) const
        {
            return SubmitCallable(&TimestreamInfluxDBClient::ListDbInstances, request);
        }
 
        template<typename ListDbInstancesRequestT = Model::ListDbInstancesRequest>
        void ListDbInstancesAsync(const ListDbInstancesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListDbInstancesRequestT& request = {}) const
        {
            return SubmitAsync(&TimestreamInfluxDBClient::ListDbInstances, request, handler, context);
        }
 
        virtual Model::ListDbInstancesForClusterOutcome ListDbInstancesForCluster(const Model::ListDbInstancesForClusterRequest& request) const;
 
        template<typename ListDbInstancesForClusterRequestT = Model::ListDbInstancesForClusterRequest>
        Model::ListDbInstancesForClusterOutcomeCallable ListDbInstancesForClusterCallable(const ListDbInstancesForClusterRequestT& request) const
        {
            return SubmitCallable(&TimestreamInfluxDBClient::ListDbInstancesForCluster, request);
        }
 
        template<typename ListDbInstancesForClusterRequestT = Model::ListDbInstancesForClusterRequest>
        void ListDbInstancesForClusterAsync(const ListDbInstancesForClusterRequestT& request, const ListDbInstancesForClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TimestreamInfluxDBClient::ListDbInstancesForCluster, request, handler, context);
        }
 
        virtual Model::ListDbParameterGroupsOutcome ListDbParameterGroups(const Model::ListDbParameterGroupsRequest& request = {}) const;
 
        template<typename ListDbParameterGroupsRequestT = Model::ListDbParameterGroupsRequest>
        Model::ListDbParameterGroupsOutcomeCallable ListDbParameterGroupsCallable(const ListDbParameterGroupsRequestT& request = {}) const
        {
            return SubmitCallable(&TimestreamInfluxDBClient::ListDbParameterGroups, request);
        }
 
        template<typename ListDbParameterGroupsRequestT = Model::ListDbParameterGroupsRequest>
        void ListDbParameterGroupsAsync(const ListDbParameterGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListDbParameterGroupsRequestT& request = {}) const
        {
            return SubmitAsync(&TimestreamInfluxDBClient::ListDbParameterGroups, 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(&TimestreamInfluxDBClient::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(&TimestreamInfluxDBClient::ListTagsForResource, 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(&TimestreamInfluxDBClient::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(&TimestreamInfluxDBClient::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(&TimestreamInfluxDBClient::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(&TimestreamInfluxDBClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateDbClusterOutcome UpdateDbCluster(const Model::UpdateDbClusterRequest& request) const;
 
        template<typename UpdateDbClusterRequestT = Model::UpdateDbClusterRequest>
        Model::UpdateDbClusterOutcomeCallable UpdateDbClusterCallable(const UpdateDbClusterRequestT& request) const
        {
            return SubmitCallable(&TimestreamInfluxDBClient::UpdateDbCluster, request);
        }
 
        template<typename UpdateDbClusterRequestT = Model::UpdateDbClusterRequest>
        void UpdateDbClusterAsync(const UpdateDbClusterRequestT& request, const UpdateDbClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TimestreamInfluxDBClient::UpdateDbCluster, request, handler, context);
        }
 
        virtual Model::UpdateDbInstanceOutcome UpdateDbInstance(const Model::UpdateDbInstanceRequest& request) const;
 
        template<typename UpdateDbInstanceRequestT = Model::UpdateDbInstanceRequest>
        Model::UpdateDbInstanceOutcomeCallable UpdateDbInstanceCallable(const UpdateDbInstanceRequestT& request) const
        {
            return SubmitCallable(&TimestreamInfluxDBClient::UpdateDbInstance, request);
        }
 
        template<typename UpdateDbInstanceRequestT = Model::UpdateDbInstanceRequest>
        void UpdateDbInstanceAsync(const UpdateDbInstanceRequestT& request, const UpdateDbInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TimestreamInfluxDBClient::UpdateDbInstance, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<TimestreamInfluxDBEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<TimestreamInfluxDBClient>;
      void init(const TimestreamInfluxDBClientConfiguration& clientConfiguration);
 
      TimestreamInfluxDBClientConfiguration m_clientConfiguration;
      std::shared_ptr<TimestreamInfluxDBEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace TimestreamInfluxDB
} // namespace Aws