EMRContainersClient.h

 
#pragma once
#include <aws/emr-containers/EMRContainers_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/emr-containers/EMRContainersServiceClientModel.h>
 
namespace Aws
{
namespace EMRContainers
{
  class AWS_EMRCONTAINERS_API EMRContainersClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<EMRContainersClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef EMRContainersClientConfiguration ClientConfigurationType;
      typedef EMRContainersEndpointProvider EndpointProviderType;
 
        EMRContainersClient(const Aws::EMRContainers::EMRContainersClientConfiguration& clientConfiguration = Aws::EMRContainers::EMRContainersClientConfiguration(),
                            std::shared_ptr<EMRContainersEndpointProviderBase> endpointProvider = nullptr);
 
        EMRContainersClient(const Aws::Auth::AWSCredentials& credentials,
                            std::shared_ptr<EMRContainersEndpointProviderBase> endpointProvider = nullptr,
                            const Aws::EMRContainers::EMRContainersClientConfiguration& clientConfiguration = Aws::EMRContainers::EMRContainersClientConfiguration());
 
        EMRContainersClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                            std::shared_ptr<EMRContainersEndpointProviderBase> endpointProvider = nullptr,
                            const Aws::EMRContainers::EMRContainersClientConfiguration& clientConfiguration = Aws::EMRContainers::EMRContainersClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        EMRContainersClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        EMRContainersClient(const Aws::Auth::AWSCredentials& credentials,
                            const Aws::Client::ClientConfiguration& clientConfiguration);
 
        EMRContainersClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                            const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~EMRContainersClient();
 
        virtual Model::CancelJobRunOutcome CancelJobRun(const Model::CancelJobRunRequest& request) const;
 
        template<typename CancelJobRunRequestT = Model::CancelJobRunRequest>
        Model::CancelJobRunOutcomeCallable CancelJobRunCallable(const CancelJobRunRequestT& request) const
        {
            return SubmitCallable(&EMRContainersClient::CancelJobRun, request);
        }
 
        template<typename CancelJobRunRequestT = Model::CancelJobRunRequest>
        void CancelJobRunAsync(const CancelJobRunRequestT& request, const CancelJobRunResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EMRContainersClient::CancelJobRun, request, handler, context);
        }
 
        virtual Model::CreateJobTemplateOutcome CreateJobTemplate(const Model::CreateJobTemplateRequest& request) const;
 
        template<typename CreateJobTemplateRequestT = Model::CreateJobTemplateRequest>
        Model::CreateJobTemplateOutcomeCallable CreateJobTemplateCallable(const CreateJobTemplateRequestT& request) const
        {
            return SubmitCallable(&EMRContainersClient::CreateJobTemplate, request);
        }
 
        template<typename CreateJobTemplateRequestT = Model::CreateJobTemplateRequest>
        void CreateJobTemplateAsync(const CreateJobTemplateRequestT& request, const CreateJobTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EMRContainersClient::CreateJobTemplate, request, handler, context);
        }
 
        virtual Model::CreateManagedEndpointOutcome CreateManagedEndpoint(const Model::CreateManagedEndpointRequest& request) const;
 
        template<typename CreateManagedEndpointRequestT = Model::CreateManagedEndpointRequest>
        Model::CreateManagedEndpointOutcomeCallable CreateManagedEndpointCallable(const CreateManagedEndpointRequestT& request) const
        {
            return SubmitCallable(&EMRContainersClient::CreateManagedEndpoint, request);
        }
 
        template<typename CreateManagedEndpointRequestT = Model::CreateManagedEndpointRequest>
        void CreateManagedEndpointAsync(const CreateManagedEndpointRequestT& request, const CreateManagedEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EMRContainersClient::CreateManagedEndpoint, request, handler, context);
        }
 
        virtual Model::CreateSecurityConfigurationOutcome CreateSecurityConfiguration(const Model::CreateSecurityConfigurationRequest& request) const;
 
        template<typename CreateSecurityConfigurationRequestT = Model::CreateSecurityConfigurationRequest>
        Model::CreateSecurityConfigurationOutcomeCallable CreateSecurityConfigurationCallable(const CreateSecurityConfigurationRequestT& request) const
        {
            return SubmitCallable(&EMRContainersClient::CreateSecurityConfiguration, request);
        }
 
        template<typename CreateSecurityConfigurationRequestT = Model::CreateSecurityConfigurationRequest>
        void CreateSecurityConfigurationAsync(const CreateSecurityConfigurationRequestT& request, const CreateSecurityConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EMRContainersClient::CreateSecurityConfiguration, request, handler, context);
        }
 
        virtual Model::CreateVirtualClusterOutcome CreateVirtualCluster(const Model::CreateVirtualClusterRequest& request) const;
 
        template<typename CreateVirtualClusterRequestT = Model::CreateVirtualClusterRequest>
        Model::CreateVirtualClusterOutcomeCallable CreateVirtualClusterCallable(const CreateVirtualClusterRequestT& request) const
        {
            return SubmitCallable(&EMRContainersClient::CreateVirtualCluster, request);
        }
 
        template<typename CreateVirtualClusterRequestT = Model::CreateVirtualClusterRequest>
        void CreateVirtualClusterAsync(const CreateVirtualClusterRequestT& request, const CreateVirtualClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EMRContainersClient::CreateVirtualCluster, request, handler, context);
        }
 
        virtual Model::DeleteJobTemplateOutcome DeleteJobTemplate(const Model::DeleteJobTemplateRequest& request) const;
 
        template<typename DeleteJobTemplateRequestT = Model::DeleteJobTemplateRequest>
        Model::DeleteJobTemplateOutcomeCallable DeleteJobTemplateCallable(const DeleteJobTemplateRequestT& request) const
        {
            return SubmitCallable(&EMRContainersClient::DeleteJobTemplate, request);
        }
 
        template<typename DeleteJobTemplateRequestT = Model::DeleteJobTemplateRequest>
        void DeleteJobTemplateAsync(const DeleteJobTemplateRequestT& request, const DeleteJobTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EMRContainersClient::DeleteJobTemplate, request, handler, context);
        }
 
        virtual Model::DeleteManagedEndpointOutcome DeleteManagedEndpoint(const Model::DeleteManagedEndpointRequest& request) const;
 
        template<typename DeleteManagedEndpointRequestT = Model::DeleteManagedEndpointRequest>
        Model::DeleteManagedEndpointOutcomeCallable DeleteManagedEndpointCallable(const DeleteManagedEndpointRequestT& request) const
        {
            return SubmitCallable(&EMRContainersClient::DeleteManagedEndpoint, request);
        }
 
        template<typename DeleteManagedEndpointRequestT = Model::DeleteManagedEndpointRequest>
        void DeleteManagedEndpointAsync(const DeleteManagedEndpointRequestT& request, const DeleteManagedEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EMRContainersClient::DeleteManagedEndpoint, request, handler, context);
        }
 
        virtual Model::DeleteVirtualClusterOutcome DeleteVirtualCluster(const Model::DeleteVirtualClusterRequest& request) const;
 
        template<typename DeleteVirtualClusterRequestT = Model::DeleteVirtualClusterRequest>
        Model::DeleteVirtualClusterOutcomeCallable DeleteVirtualClusterCallable(const DeleteVirtualClusterRequestT& request) const
        {
            return SubmitCallable(&EMRContainersClient::DeleteVirtualCluster, request);
        }
 
        template<typename DeleteVirtualClusterRequestT = Model::DeleteVirtualClusterRequest>
        void DeleteVirtualClusterAsync(const DeleteVirtualClusterRequestT& request, const DeleteVirtualClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EMRContainersClient::DeleteVirtualCluster, request, handler, context);
        }
 
        virtual Model::DescribeJobRunOutcome DescribeJobRun(const Model::DescribeJobRunRequest& request) const;
 
        template<typename DescribeJobRunRequestT = Model::DescribeJobRunRequest>
        Model::DescribeJobRunOutcomeCallable DescribeJobRunCallable(const DescribeJobRunRequestT& request) const
        {
            return SubmitCallable(&EMRContainersClient::DescribeJobRun, request);
        }
 
        template<typename DescribeJobRunRequestT = Model::DescribeJobRunRequest>
        void DescribeJobRunAsync(const DescribeJobRunRequestT& request, const DescribeJobRunResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EMRContainersClient::DescribeJobRun, request, handler, context);
        }
 
        virtual Model::DescribeJobTemplateOutcome DescribeJobTemplate(const Model::DescribeJobTemplateRequest& request) const;
 
        template<typename DescribeJobTemplateRequestT = Model::DescribeJobTemplateRequest>
        Model::DescribeJobTemplateOutcomeCallable DescribeJobTemplateCallable(const DescribeJobTemplateRequestT& request) const
        {
            return SubmitCallable(&EMRContainersClient::DescribeJobTemplate, request);
        }
 
        template<typename DescribeJobTemplateRequestT = Model::DescribeJobTemplateRequest>
        void DescribeJobTemplateAsync(const DescribeJobTemplateRequestT& request, const DescribeJobTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EMRContainersClient::DescribeJobTemplate, request, handler, context);
        }
 
        virtual Model::DescribeManagedEndpointOutcome DescribeManagedEndpoint(const Model::DescribeManagedEndpointRequest& request) const;
 
        template<typename DescribeManagedEndpointRequestT = Model::DescribeManagedEndpointRequest>
        Model::DescribeManagedEndpointOutcomeCallable DescribeManagedEndpointCallable(const DescribeManagedEndpointRequestT& request) const
        {
            return SubmitCallable(&EMRContainersClient::DescribeManagedEndpoint, request);
        }
 
        template<typename DescribeManagedEndpointRequestT = Model::DescribeManagedEndpointRequest>
        void DescribeManagedEndpointAsync(const DescribeManagedEndpointRequestT& request, const DescribeManagedEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EMRContainersClient::DescribeManagedEndpoint, request, handler, context);
        }
 
        virtual Model::DescribeSecurityConfigurationOutcome DescribeSecurityConfiguration(const Model::DescribeSecurityConfigurationRequest& request) const;
 
        template<typename DescribeSecurityConfigurationRequestT = Model::DescribeSecurityConfigurationRequest>
        Model::DescribeSecurityConfigurationOutcomeCallable DescribeSecurityConfigurationCallable(const DescribeSecurityConfigurationRequestT& request) const
        {
            return SubmitCallable(&EMRContainersClient::DescribeSecurityConfiguration, request);
        }
 
        template<typename DescribeSecurityConfigurationRequestT = Model::DescribeSecurityConfigurationRequest>
        void DescribeSecurityConfigurationAsync(const DescribeSecurityConfigurationRequestT& request, const DescribeSecurityConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EMRContainersClient::DescribeSecurityConfiguration, request, handler, context);
        }
 
        virtual Model::DescribeVirtualClusterOutcome DescribeVirtualCluster(const Model::DescribeVirtualClusterRequest& request) const;
 
        template<typename DescribeVirtualClusterRequestT = Model::DescribeVirtualClusterRequest>
        Model::DescribeVirtualClusterOutcomeCallable DescribeVirtualClusterCallable(const DescribeVirtualClusterRequestT& request) const
        {
            return SubmitCallable(&EMRContainersClient::DescribeVirtualCluster, request);
        }
 
        template<typename DescribeVirtualClusterRequestT = Model::DescribeVirtualClusterRequest>
        void DescribeVirtualClusterAsync(const DescribeVirtualClusterRequestT& request, const DescribeVirtualClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EMRContainersClient::DescribeVirtualCluster, request, handler, context);
        }
 
        virtual Model::GetManagedEndpointSessionCredentialsOutcome GetManagedEndpointSessionCredentials(const Model::GetManagedEndpointSessionCredentialsRequest& request) const;
 
        template<typename GetManagedEndpointSessionCredentialsRequestT = Model::GetManagedEndpointSessionCredentialsRequest>
        Model::GetManagedEndpointSessionCredentialsOutcomeCallable GetManagedEndpointSessionCredentialsCallable(const GetManagedEndpointSessionCredentialsRequestT& request) const
        {
            return SubmitCallable(&EMRContainersClient::GetManagedEndpointSessionCredentials, request);
        }
 
        template<typename GetManagedEndpointSessionCredentialsRequestT = Model::GetManagedEndpointSessionCredentialsRequest>
        void GetManagedEndpointSessionCredentialsAsync(const GetManagedEndpointSessionCredentialsRequestT& request, const GetManagedEndpointSessionCredentialsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EMRContainersClient::GetManagedEndpointSessionCredentials, request, handler, context);
        }
 
        virtual Model::ListJobRunsOutcome ListJobRuns(const Model::ListJobRunsRequest& request) const;
 
        template<typename ListJobRunsRequestT = Model::ListJobRunsRequest>
        Model::ListJobRunsOutcomeCallable ListJobRunsCallable(const ListJobRunsRequestT& request) const
        {
            return SubmitCallable(&EMRContainersClient::ListJobRuns, request);
        }
 
        template<typename ListJobRunsRequestT = Model::ListJobRunsRequest>
        void ListJobRunsAsync(const ListJobRunsRequestT& request, const ListJobRunsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EMRContainersClient::ListJobRuns, request, handler, context);
        }
 
        virtual Model::ListJobTemplatesOutcome ListJobTemplates(const Model::ListJobTemplatesRequest& request = {}) const;
 
        template<typename ListJobTemplatesRequestT = Model::ListJobTemplatesRequest>
        Model::ListJobTemplatesOutcomeCallable ListJobTemplatesCallable(const ListJobTemplatesRequestT& request = {}) const
        {
            return SubmitCallable(&EMRContainersClient::ListJobTemplates, request);
        }
 
        template<typename ListJobTemplatesRequestT = Model::ListJobTemplatesRequest>
        void ListJobTemplatesAsync(const ListJobTemplatesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListJobTemplatesRequestT& request = {}) const
        {
            return SubmitAsync(&EMRContainersClient::ListJobTemplates, request, handler, context);
        }
 
        virtual Model::ListManagedEndpointsOutcome ListManagedEndpoints(const Model::ListManagedEndpointsRequest& request) const;
 
        template<typename ListManagedEndpointsRequestT = Model::ListManagedEndpointsRequest>
        Model::ListManagedEndpointsOutcomeCallable ListManagedEndpointsCallable(const ListManagedEndpointsRequestT& request) const
        {
            return SubmitCallable(&EMRContainersClient::ListManagedEndpoints, request);
        }
 
        template<typename ListManagedEndpointsRequestT = Model::ListManagedEndpointsRequest>
        void ListManagedEndpointsAsync(const ListManagedEndpointsRequestT& request, const ListManagedEndpointsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EMRContainersClient::ListManagedEndpoints, request, handler, context);
        }
 
        virtual Model::ListSecurityConfigurationsOutcome ListSecurityConfigurations(const Model::ListSecurityConfigurationsRequest& request = {}) const;
 
        template<typename ListSecurityConfigurationsRequestT = Model::ListSecurityConfigurationsRequest>
        Model::ListSecurityConfigurationsOutcomeCallable ListSecurityConfigurationsCallable(const ListSecurityConfigurationsRequestT& request = {}) const
        {
            return SubmitCallable(&EMRContainersClient::ListSecurityConfigurations, request);
        }
 
        template<typename ListSecurityConfigurationsRequestT = Model::ListSecurityConfigurationsRequest>
        void ListSecurityConfigurationsAsync(const ListSecurityConfigurationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListSecurityConfigurationsRequestT& request = {}) const
        {
            return SubmitAsync(&EMRContainersClient::ListSecurityConfigurations, 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(&EMRContainersClient::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(&EMRContainersClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::ListVirtualClustersOutcome ListVirtualClusters(const Model::ListVirtualClustersRequest& request = {}) const;
 
        template<typename ListVirtualClustersRequestT = Model::ListVirtualClustersRequest>
        Model::ListVirtualClustersOutcomeCallable ListVirtualClustersCallable(const ListVirtualClustersRequestT& request = {}) const
        {
            return SubmitCallable(&EMRContainersClient::ListVirtualClusters, request);
        }
 
        template<typename ListVirtualClustersRequestT = Model::ListVirtualClustersRequest>
        void ListVirtualClustersAsync(const ListVirtualClustersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListVirtualClustersRequestT& request = {}) const
        {
            return SubmitAsync(&EMRContainersClient::ListVirtualClusters, request, handler, context);
        }
 
        virtual Model::StartJobRunOutcome StartJobRun(const Model::StartJobRunRequest& request) const;
 
        template<typename StartJobRunRequestT = Model::StartJobRunRequest>
        Model::StartJobRunOutcomeCallable StartJobRunCallable(const StartJobRunRequestT& request) const
        {
            return SubmitCallable(&EMRContainersClient::StartJobRun, request);
        }
 
        template<typename StartJobRunRequestT = Model::StartJobRunRequest>
        void StartJobRunAsync(const StartJobRunRequestT& request, const StartJobRunResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&EMRContainersClient::StartJobRun, 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(&EMRContainersClient::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(&EMRContainersClient::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(&EMRContainersClient::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(&EMRContainersClient::UntagResource, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<EMRContainersEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<EMRContainersClient>;
      void init(const EMRContainersClientConfiguration& clientConfiguration);
 
      EMRContainersClientConfiguration m_clientConfiguration;
      std::shared_ptr<EMRContainersEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace EMRContainers
} // namespace Aws