FinspaceClient.h

 
#pragma once
#include <aws/finspace/Finspace_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/finspace/FinspaceServiceClientModel.h>
 
namespace Aws
{
namespace finspace
{
  class AWS_FINSPACE_API FinspaceClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<FinspaceClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef FinspaceClientConfiguration ClientConfigurationType;
      typedef FinspaceEndpointProvider EndpointProviderType;
 
        FinspaceClient(const Aws::finspace::FinspaceClientConfiguration& clientConfiguration = Aws::finspace::FinspaceClientConfiguration(),
                       std::shared_ptr<FinspaceEndpointProviderBase> endpointProvider = nullptr);
 
        FinspaceClient(const Aws::Auth::AWSCredentials& credentials,
                       std::shared_ptr<FinspaceEndpointProviderBase> endpointProvider = nullptr,
                       const Aws::finspace::FinspaceClientConfiguration& clientConfiguration = Aws::finspace::FinspaceClientConfiguration());
 
        FinspaceClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                       std::shared_ptr<FinspaceEndpointProviderBase> endpointProvider = nullptr,
                       const Aws::finspace::FinspaceClientConfiguration& clientConfiguration = Aws::finspace::FinspaceClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        FinspaceClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        FinspaceClient(const Aws::Auth::AWSCredentials& credentials,
                       const Aws::Client::ClientConfiguration& clientConfiguration);
 
        FinspaceClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                       const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~FinspaceClient();
 
        virtual Model::CreateKxChangesetOutcome CreateKxChangeset(const Model::CreateKxChangesetRequest& request) const;
 
        template<typename CreateKxChangesetRequestT = Model::CreateKxChangesetRequest>
        Model::CreateKxChangesetOutcomeCallable CreateKxChangesetCallable(const CreateKxChangesetRequestT& request) const
        {
            return SubmitCallable(&FinspaceClient::CreateKxChangeset, request);
        }
 
        template<typename CreateKxChangesetRequestT = Model::CreateKxChangesetRequest>
        void CreateKxChangesetAsync(const CreateKxChangesetRequestT& request, const CreateKxChangesetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FinspaceClient::CreateKxChangeset, request, handler, context);
        }
 
        virtual Model::CreateKxClusterOutcome CreateKxCluster(const Model::CreateKxClusterRequest& request) const;
 
        template<typename CreateKxClusterRequestT = Model::CreateKxClusterRequest>
        Model::CreateKxClusterOutcomeCallable CreateKxClusterCallable(const CreateKxClusterRequestT& request) const
        {
            return SubmitCallable(&FinspaceClient::CreateKxCluster, request);
        }
 
        template<typename CreateKxClusterRequestT = Model::CreateKxClusterRequest>
        void CreateKxClusterAsync(const CreateKxClusterRequestT& request, const CreateKxClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FinspaceClient::CreateKxCluster, request, handler, context);
        }
 
        virtual Model::CreateKxDatabaseOutcome CreateKxDatabase(const Model::CreateKxDatabaseRequest& request) const;
 
        template<typename CreateKxDatabaseRequestT = Model::CreateKxDatabaseRequest>
        Model::CreateKxDatabaseOutcomeCallable CreateKxDatabaseCallable(const CreateKxDatabaseRequestT& request) const
        {
            return SubmitCallable(&FinspaceClient::CreateKxDatabase, request);
        }
 
        template<typename CreateKxDatabaseRequestT = Model::CreateKxDatabaseRequest>
        void CreateKxDatabaseAsync(const CreateKxDatabaseRequestT& request, const CreateKxDatabaseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FinspaceClient::CreateKxDatabase, request, handler, context);
        }
 
        virtual Model::CreateKxDataviewOutcome CreateKxDataview(const Model::CreateKxDataviewRequest& request) const;
 
        template<typename CreateKxDataviewRequestT = Model::CreateKxDataviewRequest>
        Model::CreateKxDataviewOutcomeCallable CreateKxDataviewCallable(const CreateKxDataviewRequestT& request) const
        {
            return SubmitCallable(&FinspaceClient::CreateKxDataview, request);
        }
 
        template<typename CreateKxDataviewRequestT = Model::CreateKxDataviewRequest>
        void CreateKxDataviewAsync(const CreateKxDataviewRequestT& request, const CreateKxDataviewResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FinspaceClient::CreateKxDataview, request, handler, context);
        }
 
        virtual Model::CreateKxEnvironmentOutcome CreateKxEnvironment(const Model::CreateKxEnvironmentRequest& request) const;
 
        template<typename CreateKxEnvironmentRequestT = Model::CreateKxEnvironmentRequest>
        Model::CreateKxEnvironmentOutcomeCallable CreateKxEnvironmentCallable(const CreateKxEnvironmentRequestT& request) const
        {
            return SubmitCallable(&FinspaceClient::CreateKxEnvironment, request);
        }
 
        template<typename CreateKxEnvironmentRequestT = Model::CreateKxEnvironmentRequest>
        void CreateKxEnvironmentAsync(const CreateKxEnvironmentRequestT& request, const CreateKxEnvironmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FinspaceClient::CreateKxEnvironment, request, handler, context);
        }
 
        virtual Model::CreateKxScalingGroupOutcome CreateKxScalingGroup(const Model::CreateKxScalingGroupRequest& request) const;
 
        template<typename CreateKxScalingGroupRequestT = Model::CreateKxScalingGroupRequest>
        Model::CreateKxScalingGroupOutcomeCallable CreateKxScalingGroupCallable(const CreateKxScalingGroupRequestT& request) const
        {
            return SubmitCallable(&FinspaceClient::CreateKxScalingGroup, request);
        }
 
        template<typename CreateKxScalingGroupRequestT = Model::CreateKxScalingGroupRequest>
        void CreateKxScalingGroupAsync(const CreateKxScalingGroupRequestT& request, const CreateKxScalingGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FinspaceClient::CreateKxScalingGroup, request, handler, context);
        }
 
        virtual Model::CreateKxUserOutcome CreateKxUser(const Model::CreateKxUserRequest& request) const;
 
        template<typename CreateKxUserRequestT = Model::CreateKxUserRequest>
        Model::CreateKxUserOutcomeCallable CreateKxUserCallable(const CreateKxUserRequestT& request) const
        {
            return SubmitCallable(&FinspaceClient::CreateKxUser, request);
        }
 
        template<typename CreateKxUserRequestT = Model::CreateKxUserRequest>
        void CreateKxUserAsync(const CreateKxUserRequestT& request, const CreateKxUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FinspaceClient::CreateKxUser, request, handler, context);
        }
 
        virtual Model::CreateKxVolumeOutcome CreateKxVolume(const Model::CreateKxVolumeRequest& request) const;
 
        template<typename CreateKxVolumeRequestT = Model::CreateKxVolumeRequest>
        Model::CreateKxVolumeOutcomeCallable CreateKxVolumeCallable(const CreateKxVolumeRequestT& request) const
        {
            return SubmitCallable(&FinspaceClient::CreateKxVolume, request);
        }
 
        template<typename CreateKxVolumeRequestT = Model::CreateKxVolumeRequest>
        void CreateKxVolumeAsync(const CreateKxVolumeRequestT& request, const CreateKxVolumeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FinspaceClient::CreateKxVolume, request, handler, context);
        }
 
        virtual Model::DeleteKxClusterOutcome DeleteKxCluster(const Model::DeleteKxClusterRequest& request) const;
 
        template<typename DeleteKxClusterRequestT = Model::DeleteKxClusterRequest>
        Model::DeleteKxClusterOutcomeCallable DeleteKxClusterCallable(const DeleteKxClusterRequestT& request) const
        {
            return SubmitCallable(&FinspaceClient::DeleteKxCluster, request);
        }
 
        template<typename DeleteKxClusterRequestT = Model::DeleteKxClusterRequest>
        void DeleteKxClusterAsync(const DeleteKxClusterRequestT& request, const DeleteKxClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FinspaceClient::DeleteKxCluster, request, handler, context);
        }
 
        virtual Model::DeleteKxClusterNodeOutcome DeleteKxClusterNode(const Model::DeleteKxClusterNodeRequest& request) const;
 
        template<typename DeleteKxClusterNodeRequestT = Model::DeleteKxClusterNodeRequest>
        Model::DeleteKxClusterNodeOutcomeCallable DeleteKxClusterNodeCallable(const DeleteKxClusterNodeRequestT& request) const
        {
            return SubmitCallable(&FinspaceClient::DeleteKxClusterNode, request);
        }
 
        template<typename DeleteKxClusterNodeRequestT = Model::DeleteKxClusterNodeRequest>
        void DeleteKxClusterNodeAsync(const DeleteKxClusterNodeRequestT& request, const DeleteKxClusterNodeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FinspaceClient::DeleteKxClusterNode, request, handler, context);
        }
 
        virtual Model::DeleteKxDatabaseOutcome DeleteKxDatabase(const Model::DeleteKxDatabaseRequest& request) const;
 
        template<typename DeleteKxDatabaseRequestT = Model::DeleteKxDatabaseRequest>
        Model::DeleteKxDatabaseOutcomeCallable DeleteKxDatabaseCallable(const DeleteKxDatabaseRequestT& request) const
        {
            return SubmitCallable(&FinspaceClient::DeleteKxDatabase, request);
        }
 
        template<typename DeleteKxDatabaseRequestT = Model::DeleteKxDatabaseRequest>
        void DeleteKxDatabaseAsync(const DeleteKxDatabaseRequestT& request, const DeleteKxDatabaseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FinspaceClient::DeleteKxDatabase, request, handler, context);
        }
 
        virtual Model::DeleteKxDataviewOutcome DeleteKxDataview(const Model::DeleteKxDataviewRequest& request) const;
 
        template<typename DeleteKxDataviewRequestT = Model::DeleteKxDataviewRequest>
        Model::DeleteKxDataviewOutcomeCallable DeleteKxDataviewCallable(const DeleteKxDataviewRequestT& request) const
        {
            return SubmitCallable(&FinspaceClient::DeleteKxDataview, request);
        }
 
        template<typename DeleteKxDataviewRequestT = Model::DeleteKxDataviewRequest>
        void DeleteKxDataviewAsync(const DeleteKxDataviewRequestT& request, const DeleteKxDataviewResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FinspaceClient::DeleteKxDataview, request, handler, context);
        }
 
        virtual Model::DeleteKxEnvironmentOutcome DeleteKxEnvironment(const Model::DeleteKxEnvironmentRequest& request) const;
 
        template<typename DeleteKxEnvironmentRequestT = Model::DeleteKxEnvironmentRequest>
        Model::DeleteKxEnvironmentOutcomeCallable DeleteKxEnvironmentCallable(const DeleteKxEnvironmentRequestT& request) const
        {
            return SubmitCallable(&FinspaceClient::DeleteKxEnvironment, request);
        }
 
        template<typename DeleteKxEnvironmentRequestT = Model::DeleteKxEnvironmentRequest>
        void DeleteKxEnvironmentAsync(const DeleteKxEnvironmentRequestT& request, const DeleteKxEnvironmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FinspaceClient::DeleteKxEnvironment, request, handler, context);
        }
 
        virtual Model::DeleteKxScalingGroupOutcome DeleteKxScalingGroup(const Model::DeleteKxScalingGroupRequest& request) const;
 
        template<typename DeleteKxScalingGroupRequestT = Model::DeleteKxScalingGroupRequest>
        Model::DeleteKxScalingGroupOutcomeCallable DeleteKxScalingGroupCallable(const DeleteKxScalingGroupRequestT& request) const
        {
            return SubmitCallable(&FinspaceClient::DeleteKxScalingGroup, request);
        }
 
        template<typename DeleteKxScalingGroupRequestT = Model::DeleteKxScalingGroupRequest>
        void DeleteKxScalingGroupAsync(const DeleteKxScalingGroupRequestT& request, const DeleteKxScalingGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FinspaceClient::DeleteKxScalingGroup, request, handler, context);
        }
 
        virtual Model::DeleteKxUserOutcome DeleteKxUser(const Model::DeleteKxUserRequest& request) const;
 
        template<typename DeleteKxUserRequestT = Model::DeleteKxUserRequest>
        Model::DeleteKxUserOutcomeCallable DeleteKxUserCallable(const DeleteKxUserRequestT& request) const
        {
            return SubmitCallable(&FinspaceClient::DeleteKxUser, request);
        }
 
        template<typename DeleteKxUserRequestT = Model::DeleteKxUserRequest>
        void DeleteKxUserAsync(const DeleteKxUserRequestT& request, const DeleteKxUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FinspaceClient::DeleteKxUser, request, handler, context);
        }
 
        virtual Model::DeleteKxVolumeOutcome DeleteKxVolume(const Model::DeleteKxVolumeRequest& request) const;
 
        template<typename DeleteKxVolumeRequestT = Model::DeleteKxVolumeRequest>
        Model::DeleteKxVolumeOutcomeCallable DeleteKxVolumeCallable(const DeleteKxVolumeRequestT& request) const
        {
            return SubmitCallable(&FinspaceClient::DeleteKxVolume, request);
        }
 
        template<typename DeleteKxVolumeRequestT = Model::DeleteKxVolumeRequest>
        void DeleteKxVolumeAsync(const DeleteKxVolumeRequestT& request, const DeleteKxVolumeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FinspaceClient::DeleteKxVolume, request, handler, context);
        }
 
        virtual Model::GetKxChangesetOutcome GetKxChangeset(const Model::GetKxChangesetRequest& request) const;
 
        template<typename GetKxChangesetRequestT = Model::GetKxChangesetRequest>
        Model::GetKxChangesetOutcomeCallable GetKxChangesetCallable(const GetKxChangesetRequestT& request) const
        {
            return SubmitCallable(&FinspaceClient::GetKxChangeset, request);
        }
 
        template<typename GetKxChangesetRequestT = Model::GetKxChangesetRequest>
        void GetKxChangesetAsync(const GetKxChangesetRequestT& request, const GetKxChangesetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FinspaceClient::GetKxChangeset, request, handler, context);
        }
 
        virtual Model::GetKxClusterOutcome GetKxCluster(const Model::GetKxClusterRequest& request) const;
 
        template<typename GetKxClusterRequestT = Model::GetKxClusterRequest>
        Model::GetKxClusterOutcomeCallable GetKxClusterCallable(const GetKxClusterRequestT& request) const
        {
            return SubmitCallable(&FinspaceClient::GetKxCluster, request);
        }
 
        template<typename GetKxClusterRequestT = Model::GetKxClusterRequest>
        void GetKxClusterAsync(const GetKxClusterRequestT& request, const GetKxClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FinspaceClient::GetKxCluster, request, handler, context);
        }
 
        virtual Model::GetKxConnectionStringOutcome GetKxConnectionString(const Model::GetKxConnectionStringRequest& request) const;
 
        template<typename GetKxConnectionStringRequestT = Model::GetKxConnectionStringRequest>
        Model::GetKxConnectionStringOutcomeCallable GetKxConnectionStringCallable(const GetKxConnectionStringRequestT& request) const
        {
            return SubmitCallable(&FinspaceClient::GetKxConnectionString, request);
        }
 
        template<typename GetKxConnectionStringRequestT = Model::GetKxConnectionStringRequest>
        void GetKxConnectionStringAsync(const GetKxConnectionStringRequestT& request, const GetKxConnectionStringResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FinspaceClient::GetKxConnectionString, request, handler, context);
        }
 
        virtual Model::GetKxDatabaseOutcome GetKxDatabase(const Model::GetKxDatabaseRequest& request) const;
 
        template<typename GetKxDatabaseRequestT = Model::GetKxDatabaseRequest>
        Model::GetKxDatabaseOutcomeCallable GetKxDatabaseCallable(const GetKxDatabaseRequestT& request) const
        {
            return SubmitCallable(&FinspaceClient::GetKxDatabase, request);
        }
 
        template<typename GetKxDatabaseRequestT = Model::GetKxDatabaseRequest>
        void GetKxDatabaseAsync(const GetKxDatabaseRequestT& request, const GetKxDatabaseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FinspaceClient::GetKxDatabase, request, handler, context);
        }
 
        virtual Model::GetKxDataviewOutcome GetKxDataview(const Model::GetKxDataviewRequest& request) const;
 
        template<typename GetKxDataviewRequestT = Model::GetKxDataviewRequest>
        Model::GetKxDataviewOutcomeCallable GetKxDataviewCallable(const GetKxDataviewRequestT& request) const
        {
            return SubmitCallable(&FinspaceClient::GetKxDataview, request);
        }
 
        template<typename GetKxDataviewRequestT = Model::GetKxDataviewRequest>
        void GetKxDataviewAsync(const GetKxDataviewRequestT& request, const GetKxDataviewResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FinspaceClient::GetKxDataview, request, handler, context);
        }
 
        virtual Model::GetKxEnvironmentOutcome GetKxEnvironment(const Model::GetKxEnvironmentRequest& request) const;
 
        template<typename GetKxEnvironmentRequestT = Model::GetKxEnvironmentRequest>
        Model::GetKxEnvironmentOutcomeCallable GetKxEnvironmentCallable(const GetKxEnvironmentRequestT& request) const
        {
            return SubmitCallable(&FinspaceClient::GetKxEnvironment, request);
        }
 
        template<typename GetKxEnvironmentRequestT = Model::GetKxEnvironmentRequest>
        void GetKxEnvironmentAsync(const GetKxEnvironmentRequestT& request, const GetKxEnvironmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FinspaceClient::GetKxEnvironment, request, handler, context);
        }
 
        virtual Model::GetKxScalingGroupOutcome GetKxScalingGroup(const Model::GetKxScalingGroupRequest& request) const;
 
        template<typename GetKxScalingGroupRequestT = Model::GetKxScalingGroupRequest>
        Model::GetKxScalingGroupOutcomeCallable GetKxScalingGroupCallable(const GetKxScalingGroupRequestT& request) const
        {
            return SubmitCallable(&FinspaceClient::GetKxScalingGroup, request);
        }
 
        template<typename GetKxScalingGroupRequestT = Model::GetKxScalingGroupRequest>
        void GetKxScalingGroupAsync(const GetKxScalingGroupRequestT& request, const GetKxScalingGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FinspaceClient::GetKxScalingGroup, request, handler, context);
        }
 
        virtual Model::GetKxUserOutcome GetKxUser(const Model::GetKxUserRequest& request) const;
 
        template<typename GetKxUserRequestT = Model::GetKxUserRequest>
        Model::GetKxUserOutcomeCallable GetKxUserCallable(const GetKxUserRequestT& request) const
        {
            return SubmitCallable(&FinspaceClient::GetKxUser, request);
        }
 
        template<typename GetKxUserRequestT = Model::GetKxUserRequest>
        void GetKxUserAsync(const GetKxUserRequestT& request, const GetKxUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FinspaceClient::GetKxUser, request, handler, context);
        }
 
        virtual Model::GetKxVolumeOutcome GetKxVolume(const Model::GetKxVolumeRequest& request) const;
 
        template<typename GetKxVolumeRequestT = Model::GetKxVolumeRequest>
        Model::GetKxVolumeOutcomeCallable GetKxVolumeCallable(const GetKxVolumeRequestT& request) const
        {
            return SubmitCallable(&FinspaceClient::GetKxVolume, request);
        }
 
        template<typename GetKxVolumeRequestT = Model::GetKxVolumeRequest>
        void GetKxVolumeAsync(const GetKxVolumeRequestT& request, const GetKxVolumeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FinspaceClient::GetKxVolume, request, handler, context);
        }
 
        virtual Model::ListKxChangesetsOutcome ListKxChangesets(const Model::ListKxChangesetsRequest& request) const;
 
        template<typename ListKxChangesetsRequestT = Model::ListKxChangesetsRequest>
        Model::ListKxChangesetsOutcomeCallable ListKxChangesetsCallable(const ListKxChangesetsRequestT& request) const
        {
            return SubmitCallable(&FinspaceClient::ListKxChangesets, request);
        }
 
        template<typename ListKxChangesetsRequestT = Model::ListKxChangesetsRequest>
        void ListKxChangesetsAsync(const ListKxChangesetsRequestT& request, const ListKxChangesetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FinspaceClient::ListKxChangesets, request, handler, context);
        }
 
        virtual Model::ListKxClusterNodesOutcome ListKxClusterNodes(const Model::ListKxClusterNodesRequest& request) const;
 
        template<typename ListKxClusterNodesRequestT = Model::ListKxClusterNodesRequest>
        Model::ListKxClusterNodesOutcomeCallable ListKxClusterNodesCallable(const ListKxClusterNodesRequestT& request) const
        {
            return SubmitCallable(&FinspaceClient::ListKxClusterNodes, request);
        }
 
        template<typename ListKxClusterNodesRequestT = Model::ListKxClusterNodesRequest>
        void ListKxClusterNodesAsync(const ListKxClusterNodesRequestT& request, const ListKxClusterNodesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FinspaceClient::ListKxClusterNodes, request, handler, context);
        }
 
        virtual Model::ListKxClustersOutcome ListKxClusters(const Model::ListKxClustersRequest& request) const;
 
        template<typename ListKxClustersRequestT = Model::ListKxClustersRequest>
        Model::ListKxClustersOutcomeCallable ListKxClustersCallable(const ListKxClustersRequestT& request) const
        {
            return SubmitCallable(&FinspaceClient::ListKxClusters, request);
        }
 
        template<typename ListKxClustersRequestT = Model::ListKxClustersRequest>
        void ListKxClustersAsync(const ListKxClustersRequestT& request, const ListKxClustersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FinspaceClient::ListKxClusters, request, handler, context);
        }
 
        virtual Model::ListKxDatabasesOutcome ListKxDatabases(const Model::ListKxDatabasesRequest& request) const;
 
        template<typename ListKxDatabasesRequestT = Model::ListKxDatabasesRequest>
        Model::ListKxDatabasesOutcomeCallable ListKxDatabasesCallable(const ListKxDatabasesRequestT& request) const
        {
            return SubmitCallable(&FinspaceClient::ListKxDatabases, request);
        }
 
        template<typename ListKxDatabasesRequestT = Model::ListKxDatabasesRequest>
        void ListKxDatabasesAsync(const ListKxDatabasesRequestT& request, const ListKxDatabasesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FinspaceClient::ListKxDatabases, request, handler, context);
        }
 
        virtual Model::ListKxDataviewsOutcome ListKxDataviews(const Model::ListKxDataviewsRequest& request) const;
 
        template<typename ListKxDataviewsRequestT = Model::ListKxDataviewsRequest>
        Model::ListKxDataviewsOutcomeCallable ListKxDataviewsCallable(const ListKxDataviewsRequestT& request) const
        {
            return SubmitCallable(&FinspaceClient::ListKxDataviews, request);
        }
 
        template<typename ListKxDataviewsRequestT = Model::ListKxDataviewsRequest>
        void ListKxDataviewsAsync(const ListKxDataviewsRequestT& request, const ListKxDataviewsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FinspaceClient::ListKxDataviews, request, handler, context);
        }
 
        virtual Model::ListKxEnvironmentsOutcome ListKxEnvironments(const Model::ListKxEnvironmentsRequest& request = {}) const;
 
        template<typename ListKxEnvironmentsRequestT = Model::ListKxEnvironmentsRequest>
        Model::ListKxEnvironmentsOutcomeCallable ListKxEnvironmentsCallable(const ListKxEnvironmentsRequestT& request = {}) const
        {
            return SubmitCallable(&FinspaceClient::ListKxEnvironments, request);
        }
 
        template<typename ListKxEnvironmentsRequestT = Model::ListKxEnvironmentsRequest>
        void ListKxEnvironmentsAsync(const ListKxEnvironmentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListKxEnvironmentsRequestT& request = {}) const
        {
            return SubmitAsync(&FinspaceClient::ListKxEnvironments, request, handler, context);
        }
 
        virtual Model::ListKxScalingGroupsOutcome ListKxScalingGroups(const Model::ListKxScalingGroupsRequest& request) const;
 
        template<typename ListKxScalingGroupsRequestT = Model::ListKxScalingGroupsRequest>
        Model::ListKxScalingGroupsOutcomeCallable ListKxScalingGroupsCallable(const ListKxScalingGroupsRequestT& request) const
        {
            return SubmitCallable(&FinspaceClient::ListKxScalingGroups, request);
        }
 
        template<typename ListKxScalingGroupsRequestT = Model::ListKxScalingGroupsRequest>
        void ListKxScalingGroupsAsync(const ListKxScalingGroupsRequestT& request, const ListKxScalingGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FinspaceClient::ListKxScalingGroups, request, handler, context);
        }
 
        virtual Model::ListKxUsersOutcome ListKxUsers(const Model::ListKxUsersRequest& request) const;
 
        template<typename ListKxUsersRequestT = Model::ListKxUsersRequest>
        Model::ListKxUsersOutcomeCallable ListKxUsersCallable(const ListKxUsersRequestT& request) const
        {
            return SubmitCallable(&FinspaceClient::ListKxUsers, request);
        }
 
        template<typename ListKxUsersRequestT = Model::ListKxUsersRequest>
        void ListKxUsersAsync(const ListKxUsersRequestT& request, const ListKxUsersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FinspaceClient::ListKxUsers, request, handler, context);
        }
 
        virtual Model::ListKxVolumesOutcome ListKxVolumes(const Model::ListKxVolumesRequest& request) const;
 
        template<typename ListKxVolumesRequestT = Model::ListKxVolumesRequest>
        Model::ListKxVolumesOutcomeCallable ListKxVolumesCallable(const ListKxVolumesRequestT& request) const
        {
            return SubmitCallable(&FinspaceClient::ListKxVolumes, request);
        }
 
        template<typename ListKxVolumesRequestT = Model::ListKxVolumesRequest>
        void ListKxVolumesAsync(const ListKxVolumesRequestT& request, const ListKxVolumesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FinspaceClient::ListKxVolumes, 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(&FinspaceClient::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(&FinspaceClient::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(&FinspaceClient::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(&FinspaceClient::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(&FinspaceClient::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(&FinspaceClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateKxClusterCodeConfigurationOutcome UpdateKxClusterCodeConfiguration(const Model::UpdateKxClusterCodeConfigurationRequest& request) const;
 
        template<typename UpdateKxClusterCodeConfigurationRequestT = Model::UpdateKxClusterCodeConfigurationRequest>
        Model::UpdateKxClusterCodeConfigurationOutcomeCallable UpdateKxClusterCodeConfigurationCallable(const UpdateKxClusterCodeConfigurationRequestT& request) const
        {
            return SubmitCallable(&FinspaceClient::UpdateKxClusterCodeConfiguration, request);
        }
 
        template<typename UpdateKxClusterCodeConfigurationRequestT = Model::UpdateKxClusterCodeConfigurationRequest>
        void UpdateKxClusterCodeConfigurationAsync(const UpdateKxClusterCodeConfigurationRequestT& request, const UpdateKxClusterCodeConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FinspaceClient::UpdateKxClusterCodeConfiguration, request, handler, context);
        }
 
        virtual Model::UpdateKxClusterDatabasesOutcome UpdateKxClusterDatabases(const Model::UpdateKxClusterDatabasesRequest& request) const;
 
        template<typename UpdateKxClusterDatabasesRequestT = Model::UpdateKxClusterDatabasesRequest>
        Model::UpdateKxClusterDatabasesOutcomeCallable UpdateKxClusterDatabasesCallable(const UpdateKxClusterDatabasesRequestT& request) const
        {
            return SubmitCallable(&FinspaceClient::UpdateKxClusterDatabases, request);
        }
 
        template<typename UpdateKxClusterDatabasesRequestT = Model::UpdateKxClusterDatabasesRequest>
        void UpdateKxClusterDatabasesAsync(const UpdateKxClusterDatabasesRequestT& request, const UpdateKxClusterDatabasesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FinspaceClient::UpdateKxClusterDatabases, request, handler, context);
        }
 
        virtual Model::UpdateKxDatabaseOutcome UpdateKxDatabase(const Model::UpdateKxDatabaseRequest& request) const;
 
        template<typename UpdateKxDatabaseRequestT = Model::UpdateKxDatabaseRequest>
        Model::UpdateKxDatabaseOutcomeCallable UpdateKxDatabaseCallable(const UpdateKxDatabaseRequestT& request) const
        {
            return SubmitCallable(&FinspaceClient::UpdateKxDatabase, request);
        }
 
        template<typename UpdateKxDatabaseRequestT = Model::UpdateKxDatabaseRequest>
        void UpdateKxDatabaseAsync(const UpdateKxDatabaseRequestT& request, const UpdateKxDatabaseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FinspaceClient::UpdateKxDatabase, request, handler, context);
        }
 
        virtual Model::UpdateKxDataviewOutcome UpdateKxDataview(const Model::UpdateKxDataviewRequest& request) const;
 
        template<typename UpdateKxDataviewRequestT = Model::UpdateKxDataviewRequest>
        Model::UpdateKxDataviewOutcomeCallable UpdateKxDataviewCallable(const UpdateKxDataviewRequestT& request) const
        {
            return SubmitCallable(&FinspaceClient::UpdateKxDataview, request);
        }
 
        template<typename UpdateKxDataviewRequestT = Model::UpdateKxDataviewRequest>
        void UpdateKxDataviewAsync(const UpdateKxDataviewRequestT& request, const UpdateKxDataviewResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FinspaceClient::UpdateKxDataview, request, handler, context);
        }
 
        virtual Model::UpdateKxEnvironmentOutcome UpdateKxEnvironment(const Model::UpdateKxEnvironmentRequest& request) const;
 
        template<typename UpdateKxEnvironmentRequestT = Model::UpdateKxEnvironmentRequest>
        Model::UpdateKxEnvironmentOutcomeCallable UpdateKxEnvironmentCallable(const UpdateKxEnvironmentRequestT& request) const
        {
            return SubmitCallable(&FinspaceClient::UpdateKxEnvironment, request);
        }
 
        template<typename UpdateKxEnvironmentRequestT = Model::UpdateKxEnvironmentRequest>
        void UpdateKxEnvironmentAsync(const UpdateKxEnvironmentRequestT& request, const UpdateKxEnvironmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FinspaceClient::UpdateKxEnvironment, request, handler, context);
        }
 
        virtual Model::UpdateKxEnvironmentNetworkOutcome UpdateKxEnvironmentNetwork(const Model::UpdateKxEnvironmentNetworkRequest& request) const;
 
        template<typename UpdateKxEnvironmentNetworkRequestT = Model::UpdateKxEnvironmentNetworkRequest>
        Model::UpdateKxEnvironmentNetworkOutcomeCallable UpdateKxEnvironmentNetworkCallable(const UpdateKxEnvironmentNetworkRequestT& request) const
        {
            return SubmitCallable(&FinspaceClient::UpdateKxEnvironmentNetwork, request);
        }
 
        template<typename UpdateKxEnvironmentNetworkRequestT = Model::UpdateKxEnvironmentNetworkRequest>
        void UpdateKxEnvironmentNetworkAsync(const UpdateKxEnvironmentNetworkRequestT& request, const UpdateKxEnvironmentNetworkResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FinspaceClient::UpdateKxEnvironmentNetwork, request, handler, context);
        }
 
        virtual Model::UpdateKxUserOutcome UpdateKxUser(const Model::UpdateKxUserRequest& request) const;
 
        template<typename UpdateKxUserRequestT = Model::UpdateKxUserRequest>
        Model::UpdateKxUserOutcomeCallable UpdateKxUserCallable(const UpdateKxUserRequestT& request) const
        {
            return SubmitCallable(&FinspaceClient::UpdateKxUser, request);
        }
 
        template<typename UpdateKxUserRequestT = Model::UpdateKxUserRequest>
        void UpdateKxUserAsync(const UpdateKxUserRequestT& request, const UpdateKxUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FinspaceClient::UpdateKxUser, request, handler, context);
        }
 
        virtual Model::UpdateKxVolumeOutcome UpdateKxVolume(const Model::UpdateKxVolumeRequest& request) const;
 
        template<typename UpdateKxVolumeRequestT = Model::UpdateKxVolumeRequest>
        Model::UpdateKxVolumeOutcomeCallable UpdateKxVolumeCallable(const UpdateKxVolumeRequestT& request) const
        {
            return SubmitCallable(&FinspaceClient::UpdateKxVolume, request);
        }
 
        template<typename UpdateKxVolumeRequestT = Model::UpdateKxVolumeRequest>
        void UpdateKxVolumeAsync(const UpdateKxVolumeRequestT& request, const UpdateKxVolumeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FinspaceClient::UpdateKxVolume, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<FinspaceEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<FinspaceClient>;
      void init(const FinspaceClientConfiguration& clientConfiguration);
 
      FinspaceClientConfiguration m_clientConfiguration;
      std::shared_ptr<FinspaceEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace finspace
} // namespace Aws