WorkspacesInstancesClient.h

 
#pragma once
#include <aws/workspaces-instances/WorkspacesInstances_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/workspaces-instances/WorkspacesInstancesServiceClientModel.h>
 
namespace Aws
{
namespace WorkspacesInstances
{
  class AWS_WORKSPACESINSTANCES_API WorkspacesInstancesClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<WorkspacesInstancesEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<WorkspacesInstancesClient>;
      void init(const WorkspacesInstancesClientConfiguration& clientConfiguration);
 
      WorkspacesInstancesClientConfiguration m_clientConfiguration;
      std::shared_ptr<WorkspacesInstancesEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace WorkspacesInstances
} // namespace Aws