FinspaceClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/finspace/FinspacePaginationBase.h>
#include <aws/finspace/FinspaceServiceClientModel.h>
#include <aws/finspace/FinspaceWaiter.h>
#include <aws/finspace/Finspace_EXPORTS.h>
 
namespace Aws {
namespace finspace {
class AWS_FINSPACE_API FinspaceClient : public Aws::Client::AWSJsonClient,
                                        public Aws::Client::ClientWithAsyncTemplateMethods<FinspaceClient>,
                                        public FinspacePaginationBase<FinspaceClient>,
                                        public FinspaceWaiter<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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<FinspaceEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<FinspaceClient>;
  void init(const FinspaceClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, FinspaceError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  FinspaceClientConfiguration m_clientConfiguration;
  std::shared_ptr<FinspaceEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace finspace
}  // namespace Aws