WorkspacesInstancesClient.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/workspaces-instances/WorkspacesInstancesPaginationBase.h>
#include <aws/workspaces-instances/WorkspacesInstancesServiceClientModel.h>
#include <aws/workspaces-instances/WorkspacesInstancesWaiter.h>
#include <aws/workspaces-instances/WorkspacesInstances_EXPORTS.h>
 
namespace Aws {
namespace WorkspacesInstances {
class AWS_WORKSPACESINSTANCES_API WorkspacesInstancesClient : public Aws::Client::AWSJsonClient,
                                                              public Aws::Client::ClientWithAsyncTemplateMethods<WorkspacesInstancesClient>,
                                                              public WorkspacesInstancesPaginationBase<WorkspacesInstancesClient>,
                                                              public WorkspacesInstancesWaiter<WorkspacesInstancesClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef WorkspacesInstancesClientConfiguration ClientConfigurationType;
  typedef WorkspacesInstancesEndpointProvider EndpointProviderType;
 
  WorkspacesInstancesClient(const Aws::WorkspacesInstances::WorkspacesInstancesClientConfiguration& clientConfiguration =
                                Aws::WorkspacesInstances::WorkspacesInstancesClientConfiguration(),
                            std::shared_ptr<WorkspacesInstancesEndpointProviderBase> endpointProvider = nullptr);
 
  WorkspacesInstancesClient(const Aws::Auth::AWSCredentials& credentials,
                            std::shared_ptr<WorkspacesInstancesEndpointProviderBase> endpointProvider = nullptr,
                            const Aws::WorkspacesInstances::WorkspacesInstancesClientConfiguration& clientConfiguration =
                                Aws::WorkspacesInstances::WorkspacesInstancesClientConfiguration());
 
  WorkspacesInstancesClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                            std::shared_ptr<WorkspacesInstancesEndpointProviderBase> endpointProvider = nullptr,
                            const Aws::WorkspacesInstances::WorkspacesInstancesClientConfiguration& clientConfiguration =
                                Aws::WorkspacesInstances::WorkspacesInstancesClientConfiguration());
 
  /* Legacy constructors due deprecation */
  WorkspacesInstancesClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  WorkspacesInstancesClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  WorkspacesInstancesClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                            const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~WorkspacesInstancesClient();
 
  virtual Model::AssociateVolumeOutcome AssociateVolume(const Model::AssociateVolumeRequest& request) const;
 
  template <typename AssociateVolumeRequestT = Model::AssociateVolumeRequest>
  Model::AssociateVolumeOutcomeCallable AssociateVolumeCallable(const AssociateVolumeRequestT& request) const {
    return SubmitCallable(&WorkspacesInstancesClient::AssociateVolume, request);
  }
 
  template <typename AssociateVolumeRequestT = Model::AssociateVolumeRequest>
  void AssociateVolumeAsync(const AssociateVolumeRequestT& request, const AssociateVolumeResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WorkspacesInstancesClient::AssociateVolume, request, handler, context);
  }
 
  virtual Model::CreateVolumeOutcome CreateVolume(const Model::CreateVolumeRequest& request) const;
 
  template <typename CreateVolumeRequestT = Model::CreateVolumeRequest>
  Model::CreateVolumeOutcomeCallable CreateVolumeCallable(const CreateVolumeRequestT& request) const {
    return SubmitCallable(&WorkspacesInstancesClient::CreateVolume, request);
  }
 
  template <typename CreateVolumeRequestT = Model::CreateVolumeRequest>
  void CreateVolumeAsync(const CreateVolumeRequestT& request, const CreateVolumeResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WorkspacesInstancesClient::CreateVolume, request, handler, context);
  }
 
  virtual Model::CreateWorkspaceInstanceOutcome CreateWorkspaceInstance(const Model::CreateWorkspaceInstanceRequest& request) const;
 
  template <typename CreateWorkspaceInstanceRequestT = Model::CreateWorkspaceInstanceRequest>
  Model::CreateWorkspaceInstanceOutcomeCallable CreateWorkspaceInstanceCallable(const CreateWorkspaceInstanceRequestT& request) const {
    return SubmitCallable(&WorkspacesInstancesClient::CreateWorkspaceInstance, request);
  }
 
  template <typename CreateWorkspaceInstanceRequestT = Model::CreateWorkspaceInstanceRequest>
  void CreateWorkspaceInstanceAsync(const CreateWorkspaceInstanceRequestT& request,
                                    const CreateWorkspaceInstanceResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WorkspacesInstancesClient::CreateWorkspaceInstance, request, handler, context);
  }
 
  virtual Model::DeleteVolumeOutcome DeleteVolume(const Model::DeleteVolumeRequest& request) const;
 
  template <typename DeleteVolumeRequestT = Model::DeleteVolumeRequest>
  Model::DeleteVolumeOutcomeCallable DeleteVolumeCallable(const DeleteVolumeRequestT& request) const {
    return SubmitCallable(&WorkspacesInstancesClient::DeleteVolume, request);
  }
 
  template <typename DeleteVolumeRequestT = Model::DeleteVolumeRequest>
  void DeleteVolumeAsync(const DeleteVolumeRequestT& request, const DeleteVolumeResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WorkspacesInstancesClient::DeleteVolume, request, handler, context);
  }
 
  virtual Model::DeleteWorkspaceInstanceOutcome DeleteWorkspaceInstance(const Model::DeleteWorkspaceInstanceRequest& request) const;
 
  template <typename DeleteWorkspaceInstanceRequestT = Model::DeleteWorkspaceInstanceRequest>
  Model::DeleteWorkspaceInstanceOutcomeCallable DeleteWorkspaceInstanceCallable(const DeleteWorkspaceInstanceRequestT& request) const {
    return SubmitCallable(&WorkspacesInstancesClient::DeleteWorkspaceInstance, request);
  }
 
  template <typename DeleteWorkspaceInstanceRequestT = Model::DeleteWorkspaceInstanceRequest>
  void DeleteWorkspaceInstanceAsync(const DeleteWorkspaceInstanceRequestT& request,
                                    const DeleteWorkspaceInstanceResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WorkspacesInstancesClient::DeleteWorkspaceInstance, request, handler, context);
  }
 
  virtual Model::DisassociateVolumeOutcome DisassociateVolume(const Model::DisassociateVolumeRequest& request) const;
 
  template <typename DisassociateVolumeRequestT = Model::DisassociateVolumeRequest>
  Model::DisassociateVolumeOutcomeCallable DisassociateVolumeCallable(const DisassociateVolumeRequestT& request) const {
    return SubmitCallable(&WorkspacesInstancesClient::DisassociateVolume, request);
  }
 
  template <typename DisassociateVolumeRequestT = Model::DisassociateVolumeRequest>
  void DisassociateVolumeAsync(const DisassociateVolumeRequestT& request, const DisassociateVolumeResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WorkspacesInstancesClient::DisassociateVolume, request, handler, context);
  }
 
  virtual Model::GetWorkspaceInstanceOutcome GetWorkspaceInstance(const Model::GetWorkspaceInstanceRequest& request) const;
 
  template <typename GetWorkspaceInstanceRequestT = Model::GetWorkspaceInstanceRequest>
  Model::GetWorkspaceInstanceOutcomeCallable GetWorkspaceInstanceCallable(const GetWorkspaceInstanceRequestT& request) const {
    return SubmitCallable(&WorkspacesInstancesClient::GetWorkspaceInstance, request);
  }
 
  template <typename GetWorkspaceInstanceRequestT = Model::GetWorkspaceInstanceRequest>
  void GetWorkspaceInstanceAsync(const GetWorkspaceInstanceRequestT& request, const GetWorkspaceInstanceResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WorkspacesInstancesClient::GetWorkspaceInstance, request, handler, context);
  }
 
  virtual Model::ListInstanceTypesOutcome ListInstanceTypes(const Model::ListInstanceTypesRequest& request = {}) const;
 
  template <typename ListInstanceTypesRequestT = Model::ListInstanceTypesRequest>
  Model::ListInstanceTypesOutcomeCallable ListInstanceTypesCallable(const ListInstanceTypesRequestT& request = {}) const {
    return SubmitCallable(&WorkspacesInstancesClient::ListInstanceTypes, request);
  }
 
  template <typename ListInstanceTypesRequestT = Model::ListInstanceTypesRequest>
  void ListInstanceTypesAsync(const ListInstanceTypesResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const ListInstanceTypesRequestT& request = {}) const {
    return SubmitAsync(&WorkspacesInstancesClient::ListInstanceTypes, request, handler, context);
  }
 
  virtual Model::ListRegionsOutcome ListRegions(const Model::ListRegionsRequest& request = {}) const;
 
  template <typename ListRegionsRequestT = Model::ListRegionsRequest>
  Model::ListRegionsOutcomeCallable ListRegionsCallable(const ListRegionsRequestT& request = {}) const {
    return SubmitCallable(&WorkspacesInstancesClient::ListRegions, request);
  }
 
  template <typename ListRegionsRequestT = Model::ListRegionsRequest>
  void ListRegionsAsync(const ListRegionsResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                        const ListRegionsRequestT& request = {}) const {
    return SubmitAsync(&WorkspacesInstancesClient::ListRegions, 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(&WorkspacesInstancesClient::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(&WorkspacesInstancesClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::ListWorkspaceInstancesOutcome ListWorkspaceInstances(const Model::ListWorkspaceInstancesRequest& request = {}) const;
 
  template <typename ListWorkspaceInstancesRequestT = Model::ListWorkspaceInstancesRequest>
  Model::ListWorkspaceInstancesOutcomeCallable ListWorkspaceInstancesCallable(const ListWorkspaceInstancesRequestT& request = {}) const {
    return SubmitCallable(&WorkspacesInstancesClient::ListWorkspaceInstances, request);
  }
 
  template <typename ListWorkspaceInstancesRequestT = Model::ListWorkspaceInstancesRequest>
  void ListWorkspaceInstancesAsync(const ListWorkspaceInstancesResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                   const ListWorkspaceInstancesRequestT& request = {}) const {
    return SubmitAsync(&WorkspacesInstancesClient::ListWorkspaceInstances, 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(&WorkspacesInstancesClient::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(&WorkspacesInstancesClient::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(&WorkspacesInstancesClient::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(&WorkspacesInstancesClient::UntagResource, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<WorkspacesInstancesEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<WorkspacesInstancesClient>;
  void init(const WorkspacesInstancesClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, WorkspacesInstancesError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  WorkspacesInstancesClientConfiguration m_clientConfiguration;
  std::shared_ptr<WorkspacesInstancesEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace WorkspacesInstances
}  // namespace Aws