ImagebuilderClient.h

 
#pragma once
#include <aws/imagebuilder/Imagebuilder_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/imagebuilder/ImagebuilderServiceClientModel.h>
 
namespace Aws
{
namespace imagebuilder
{
  class AWS_IMAGEBUILDER_API ImagebuilderClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<ImagebuilderClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef ImagebuilderClientConfiguration ClientConfigurationType;
      typedef ImagebuilderEndpointProvider EndpointProviderType;
 
        ImagebuilderClient(const Aws::imagebuilder::ImagebuilderClientConfiguration& clientConfiguration = Aws::imagebuilder::ImagebuilderClientConfiguration(),
                           std::shared_ptr<ImagebuilderEndpointProviderBase> endpointProvider = nullptr);
 
        ImagebuilderClient(const Aws::Auth::AWSCredentials& credentials,
                           std::shared_ptr<ImagebuilderEndpointProviderBase> endpointProvider = nullptr,
                           const Aws::imagebuilder::ImagebuilderClientConfiguration& clientConfiguration = Aws::imagebuilder::ImagebuilderClientConfiguration());
 
        ImagebuilderClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                           std::shared_ptr<ImagebuilderEndpointProviderBase> endpointProvider = nullptr,
                           const Aws::imagebuilder::ImagebuilderClientConfiguration& clientConfiguration = Aws::imagebuilder::ImagebuilderClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        ImagebuilderClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        ImagebuilderClient(const Aws::Auth::AWSCredentials& credentials,
                           const Aws::Client::ClientConfiguration& clientConfiguration);
 
        ImagebuilderClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                           const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~ImagebuilderClient();
 
        virtual Model::CancelImageCreationOutcome CancelImageCreation(const Model::CancelImageCreationRequest& request) const;
 
        template<typename CancelImageCreationRequestT = Model::CancelImageCreationRequest>
        Model::CancelImageCreationOutcomeCallable CancelImageCreationCallable(const CancelImageCreationRequestT& request) const
        {
            return SubmitCallable(&ImagebuilderClient::CancelImageCreation, request);
        }
 
        template<typename CancelImageCreationRequestT = Model::CancelImageCreationRequest>
        void CancelImageCreationAsync(const CancelImageCreationRequestT& request, const CancelImageCreationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ImagebuilderClient::CancelImageCreation, request, handler, context);
        }
 
        virtual Model::CancelLifecycleExecutionOutcome CancelLifecycleExecution(const Model::CancelLifecycleExecutionRequest& request) const;
 
        template<typename CancelLifecycleExecutionRequestT = Model::CancelLifecycleExecutionRequest>
        Model::CancelLifecycleExecutionOutcomeCallable CancelLifecycleExecutionCallable(const CancelLifecycleExecutionRequestT& request) const
        {
            return SubmitCallable(&ImagebuilderClient::CancelLifecycleExecution, request);
        }
 
        template<typename CancelLifecycleExecutionRequestT = Model::CancelLifecycleExecutionRequest>
        void CancelLifecycleExecutionAsync(const CancelLifecycleExecutionRequestT& request, const CancelLifecycleExecutionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ImagebuilderClient::CancelLifecycleExecution, request, handler, context);
        }
 
        virtual Model::CreateComponentOutcome CreateComponent(const Model::CreateComponentRequest& request) const;
 
        template<typename CreateComponentRequestT = Model::CreateComponentRequest>
        Model::CreateComponentOutcomeCallable CreateComponentCallable(const CreateComponentRequestT& request) const
        {
            return SubmitCallable(&ImagebuilderClient::CreateComponent, request);
        }
 
        template<typename CreateComponentRequestT = Model::CreateComponentRequest>
        void CreateComponentAsync(const CreateComponentRequestT& request, const CreateComponentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ImagebuilderClient::CreateComponent, request, handler, context);
        }
 
        virtual Model::CreateContainerRecipeOutcome CreateContainerRecipe(const Model::CreateContainerRecipeRequest& request) const;
 
        template<typename CreateContainerRecipeRequestT = Model::CreateContainerRecipeRequest>
        Model::CreateContainerRecipeOutcomeCallable CreateContainerRecipeCallable(const CreateContainerRecipeRequestT& request) const
        {
            return SubmitCallable(&ImagebuilderClient::CreateContainerRecipe, request);
        }
 
        template<typename CreateContainerRecipeRequestT = Model::CreateContainerRecipeRequest>
        void CreateContainerRecipeAsync(const CreateContainerRecipeRequestT& request, const CreateContainerRecipeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ImagebuilderClient::CreateContainerRecipe, request, handler, context);
        }
 
        virtual Model::CreateDistributionConfigurationOutcome CreateDistributionConfiguration(const Model::CreateDistributionConfigurationRequest& request) const;
 
        template<typename CreateDistributionConfigurationRequestT = Model::CreateDistributionConfigurationRequest>
        Model::CreateDistributionConfigurationOutcomeCallable CreateDistributionConfigurationCallable(const CreateDistributionConfigurationRequestT& request) const
        {
            return SubmitCallable(&ImagebuilderClient::CreateDistributionConfiguration, request);
        }
 
        template<typename CreateDistributionConfigurationRequestT = Model::CreateDistributionConfigurationRequest>
        void CreateDistributionConfigurationAsync(const CreateDistributionConfigurationRequestT& request, const CreateDistributionConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ImagebuilderClient::CreateDistributionConfiguration, request, handler, context);
        }
 
        virtual Model::CreateImageOutcome CreateImage(const Model::CreateImageRequest& request) const;
 
        template<typename CreateImageRequestT = Model::CreateImageRequest>
        Model::CreateImageOutcomeCallable CreateImageCallable(const CreateImageRequestT& request) const
        {
            return SubmitCallable(&ImagebuilderClient::CreateImage, request);
        }
 
        template<typename CreateImageRequestT = Model::CreateImageRequest>
        void CreateImageAsync(const CreateImageRequestT& request, const CreateImageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ImagebuilderClient::CreateImage, request, handler, context);
        }
 
        virtual Model::CreateImagePipelineOutcome CreateImagePipeline(const Model::CreateImagePipelineRequest& request) const;
 
        template<typename CreateImagePipelineRequestT = Model::CreateImagePipelineRequest>
        Model::CreateImagePipelineOutcomeCallable CreateImagePipelineCallable(const CreateImagePipelineRequestT& request) const
        {
            return SubmitCallable(&ImagebuilderClient::CreateImagePipeline, request);
        }
 
        template<typename CreateImagePipelineRequestT = Model::CreateImagePipelineRequest>
        void CreateImagePipelineAsync(const CreateImagePipelineRequestT& request, const CreateImagePipelineResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ImagebuilderClient::CreateImagePipeline, request, handler, context);
        }
 
        virtual Model::CreateImageRecipeOutcome CreateImageRecipe(const Model::CreateImageRecipeRequest& request) const;
 
        template<typename CreateImageRecipeRequestT = Model::CreateImageRecipeRequest>
        Model::CreateImageRecipeOutcomeCallable CreateImageRecipeCallable(const CreateImageRecipeRequestT& request) const
        {
            return SubmitCallable(&ImagebuilderClient::CreateImageRecipe, request);
        }
 
        template<typename CreateImageRecipeRequestT = Model::CreateImageRecipeRequest>
        void CreateImageRecipeAsync(const CreateImageRecipeRequestT& request, const CreateImageRecipeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ImagebuilderClient::CreateImageRecipe, request, handler, context);
        }
 
        virtual Model::CreateInfrastructureConfigurationOutcome CreateInfrastructureConfiguration(const Model::CreateInfrastructureConfigurationRequest& request) const;
 
        template<typename CreateInfrastructureConfigurationRequestT = Model::CreateInfrastructureConfigurationRequest>
        Model::CreateInfrastructureConfigurationOutcomeCallable CreateInfrastructureConfigurationCallable(const CreateInfrastructureConfigurationRequestT& request) const
        {
            return SubmitCallable(&ImagebuilderClient::CreateInfrastructureConfiguration, request);
        }
 
        template<typename CreateInfrastructureConfigurationRequestT = Model::CreateInfrastructureConfigurationRequest>
        void CreateInfrastructureConfigurationAsync(const CreateInfrastructureConfigurationRequestT& request, const CreateInfrastructureConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ImagebuilderClient::CreateInfrastructureConfiguration, request, handler, context);
        }
 
        virtual Model::CreateLifecyclePolicyOutcome CreateLifecyclePolicy(const Model::CreateLifecyclePolicyRequest& request) const;
 
        template<typename CreateLifecyclePolicyRequestT = Model::CreateLifecyclePolicyRequest>
        Model::CreateLifecyclePolicyOutcomeCallable CreateLifecyclePolicyCallable(const CreateLifecyclePolicyRequestT& request) const
        {
            return SubmitCallable(&ImagebuilderClient::CreateLifecyclePolicy, request);
        }
 
        template<typename CreateLifecyclePolicyRequestT = Model::CreateLifecyclePolicyRequest>
        void CreateLifecyclePolicyAsync(const CreateLifecyclePolicyRequestT& request, const CreateLifecyclePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ImagebuilderClient::CreateLifecyclePolicy, request, handler, context);
        }
 
        virtual Model::CreateWorkflowOutcome CreateWorkflow(const Model::CreateWorkflowRequest& request) const;
 
        template<typename CreateWorkflowRequestT = Model::CreateWorkflowRequest>
        Model::CreateWorkflowOutcomeCallable CreateWorkflowCallable(const CreateWorkflowRequestT& request) const
        {
            return SubmitCallable(&ImagebuilderClient::CreateWorkflow, request);
        }
 
        template<typename CreateWorkflowRequestT = Model::CreateWorkflowRequest>
        void CreateWorkflowAsync(const CreateWorkflowRequestT& request, const CreateWorkflowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ImagebuilderClient::CreateWorkflow, request, handler, context);
        }
 
        virtual Model::DeleteComponentOutcome DeleteComponent(const Model::DeleteComponentRequest& request) const;
 
        template<typename DeleteComponentRequestT = Model::DeleteComponentRequest>
        Model::DeleteComponentOutcomeCallable DeleteComponentCallable(const DeleteComponentRequestT& request) const
        {
            return SubmitCallable(&ImagebuilderClient::DeleteComponent, request);
        }
 
        template<typename DeleteComponentRequestT = Model::DeleteComponentRequest>
        void DeleteComponentAsync(const DeleteComponentRequestT& request, const DeleteComponentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ImagebuilderClient::DeleteComponent, request, handler, context);
        }
 
        virtual Model::DeleteContainerRecipeOutcome DeleteContainerRecipe(const Model::DeleteContainerRecipeRequest& request) const;
 
        template<typename DeleteContainerRecipeRequestT = Model::DeleteContainerRecipeRequest>
        Model::DeleteContainerRecipeOutcomeCallable DeleteContainerRecipeCallable(const DeleteContainerRecipeRequestT& request) const
        {
            return SubmitCallable(&ImagebuilderClient::DeleteContainerRecipe, request);
        }
 
        template<typename DeleteContainerRecipeRequestT = Model::DeleteContainerRecipeRequest>
        void DeleteContainerRecipeAsync(const DeleteContainerRecipeRequestT& request, const DeleteContainerRecipeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ImagebuilderClient::DeleteContainerRecipe, request, handler, context);
        }
 
        virtual Model::DeleteDistributionConfigurationOutcome DeleteDistributionConfiguration(const Model::DeleteDistributionConfigurationRequest& request) const;
 
        template<typename DeleteDistributionConfigurationRequestT = Model::DeleteDistributionConfigurationRequest>
        Model::DeleteDistributionConfigurationOutcomeCallable DeleteDistributionConfigurationCallable(const DeleteDistributionConfigurationRequestT& request) const
        {
            return SubmitCallable(&ImagebuilderClient::DeleteDistributionConfiguration, request);
        }
 
        template<typename DeleteDistributionConfigurationRequestT = Model::DeleteDistributionConfigurationRequest>
        void DeleteDistributionConfigurationAsync(const DeleteDistributionConfigurationRequestT& request, const DeleteDistributionConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ImagebuilderClient::DeleteDistributionConfiguration, request, handler, context);
        }
 
        virtual Model::DeleteImageOutcome DeleteImage(const Model::DeleteImageRequest& request) const;
 
        template<typename DeleteImageRequestT = Model::DeleteImageRequest>
        Model::DeleteImageOutcomeCallable DeleteImageCallable(const DeleteImageRequestT& request) const
        {
            return SubmitCallable(&ImagebuilderClient::DeleteImage, request);
        }
 
        template<typename DeleteImageRequestT = Model::DeleteImageRequest>
        void DeleteImageAsync(const DeleteImageRequestT& request, const DeleteImageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ImagebuilderClient::DeleteImage, request, handler, context);
        }
 
        virtual Model::DeleteImagePipelineOutcome DeleteImagePipeline(const Model::DeleteImagePipelineRequest& request) const;
 
        template<typename DeleteImagePipelineRequestT = Model::DeleteImagePipelineRequest>
        Model::DeleteImagePipelineOutcomeCallable DeleteImagePipelineCallable(const DeleteImagePipelineRequestT& request) const
        {
            return SubmitCallable(&ImagebuilderClient::DeleteImagePipeline, request);
        }
 
        template<typename DeleteImagePipelineRequestT = Model::DeleteImagePipelineRequest>
        void DeleteImagePipelineAsync(const DeleteImagePipelineRequestT& request, const DeleteImagePipelineResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ImagebuilderClient::DeleteImagePipeline, request, handler, context);
        }
 
        virtual Model::DeleteImageRecipeOutcome DeleteImageRecipe(const Model::DeleteImageRecipeRequest& request) const;
 
        template<typename DeleteImageRecipeRequestT = Model::DeleteImageRecipeRequest>
        Model::DeleteImageRecipeOutcomeCallable DeleteImageRecipeCallable(const DeleteImageRecipeRequestT& request) const
        {
            return SubmitCallable(&ImagebuilderClient::DeleteImageRecipe, request);
        }
 
        template<typename DeleteImageRecipeRequestT = Model::DeleteImageRecipeRequest>
        void DeleteImageRecipeAsync(const DeleteImageRecipeRequestT& request, const DeleteImageRecipeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ImagebuilderClient::DeleteImageRecipe, request, handler, context);
        }
 
        virtual Model::DeleteInfrastructureConfigurationOutcome DeleteInfrastructureConfiguration(const Model::DeleteInfrastructureConfigurationRequest& request) const;
 
        template<typename DeleteInfrastructureConfigurationRequestT = Model::DeleteInfrastructureConfigurationRequest>
        Model::DeleteInfrastructureConfigurationOutcomeCallable DeleteInfrastructureConfigurationCallable(const DeleteInfrastructureConfigurationRequestT& request) const
        {
            return SubmitCallable(&ImagebuilderClient::DeleteInfrastructureConfiguration, request);
        }
 
        template<typename DeleteInfrastructureConfigurationRequestT = Model::DeleteInfrastructureConfigurationRequest>
        void DeleteInfrastructureConfigurationAsync(const DeleteInfrastructureConfigurationRequestT& request, const DeleteInfrastructureConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ImagebuilderClient::DeleteInfrastructureConfiguration, request, handler, context);
        }
 
        virtual Model::DeleteLifecyclePolicyOutcome DeleteLifecyclePolicy(const Model::DeleteLifecyclePolicyRequest& request) const;
 
        template<typename DeleteLifecyclePolicyRequestT = Model::DeleteLifecyclePolicyRequest>
        Model::DeleteLifecyclePolicyOutcomeCallable DeleteLifecyclePolicyCallable(const DeleteLifecyclePolicyRequestT& request) const
        {
            return SubmitCallable(&ImagebuilderClient::DeleteLifecyclePolicy, request);
        }
 
        template<typename DeleteLifecyclePolicyRequestT = Model::DeleteLifecyclePolicyRequest>
        void DeleteLifecyclePolicyAsync(const DeleteLifecyclePolicyRequestT& request, const DeleteLifecyclePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ImagebuilderClient::DeleteLifecyclePolicy, request, handler, context);
        }
 
        virtual Model::DeleteWorkflowOutcome DeleteWorkflow(const Model::DeleteWorkflowRequest& request) const;
 
        template<typename DeleteWorkflowRequestT = Model::DeleteWorkflowRequest>
        Model::DeleteWorkflowOutcomeCallable DeleteWorkflowCallable(const DeleteWorkflowRequestT& request) const
        {
            return SubmitCallable(&ImagebuilderClient::DeleteWorkflow, request);
        }
 
        template<typename DeleteWorkflowRequestT = Model::DeleteWorkflowRequest>
        void DeleteWorkflowAsync(const DeleteWorkflowRequestT& request, const DeleteWorkflowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ImagebuilderClient::DeleteWorkflow, request, handler, context);
        }
 
        virtual Model::GetComponentOutcome GetComponent(const Model::GetComponentRequest& request) const;
 
        template<typename GetComponentRequestT = Model::GetComponentRequest>
        Model::GetComponentOutcomeCallable GetComponentCallable(const GetComponentRequestT& request) const
        {
            return SubmitCallable(&ImagebuilderClient::GetComponent, request);
        }
 
        template<typename GetComponentRequestT = Model::GetComponentRequest>
        void GetComponentAsync(const GetComponentRequestT& request, const GetComponentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ImagebuilderClient::GetComponent, request, handler, context);
        }
 
        virtual Model::GetComponentPolicyOutcome GetComponentPolicy(const Model::GetComponentPolicyRequest& request) const;
 
        template<typename GetComponentPolicyRequestT = Model::GetComponentPolicyRequest>
        Model::GetComponentPolicyOutcomeCallable GetComponentPolicyCallable(const GetComponentPolicyRequestT& request) const
        {
            return SubmitCallable(&ImagebuilderClient::GetComponentPolicy, request);
        }
 
        template<typename GetComponentPolicyRequestT = Model::GetComponentPolicyRequest>
        void GetComponentPolicyAsync(const GetComponentPolicyRequestT& request, const GetComponentPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ImagebuilderClient::GetComponentPolicy, request, handler, context);
        }
 
        virtual Model::GetContainerRecipeOutcome GetContainerRecipe(const Model::GetContainerRecipeRequest& request) const;
 
        template<typename GetContainerRecipeRequestT = Model::GetContainerRecipeRequest>
        Model::GetContainerRecipeOutcomeCallable GetContainerRecipeCallable(const GetContainerRecipeRequestT& request) const
        {
            return SubmitCallable(&ImagebuilderClient::GetContainerRecipe, request);
        }
 
        template<typename GetContainerRecipeRequestT = Model::GetContainerRecipeRequest>
        void GetContainerRecipeAsync(const GetContainerRecipeRequestT& request, const GetContainerRecipeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ImagebuilderClient::GetContainerRecipe, request, handler, context);
        }
 
        virtual Model::GetContainerRecipePolicyOutcome GetContainerRecipePolicy(const Model::GetContainerRecipePolicyRequest& request) const;
 
        template<typename GetContainerRecipePolicyRequestT = Model::GetContainerRecipePolicyRequest>
        Model::GetContainerRecipePolicyOutcomeCallable GetContainerRecipePolicyCallable(const GetContainerRecipePolicyRequestT& request) const
        {
            return SubmitCallable(&ImagebuilderClient::GetContainerRecipePolicy, request);
        }
 
        template<typename GetContainerRecipePolicyRequestT = Model::GetContainerRecipePolicyRequest>
        void GetContainerRecipePolicyAsync(const GetContainerRecipePolicyRequestT& request, const GetContainerRecipePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ImagebuilderClient::GetContainerRecipePolicy, request, handler, context);
        }
 
        virtual Model::GetDistributionConfigurationOutcome GetDistributionConfiguration(const Model::GetDistributionConfigurationRequest& request) const;
 
        template<typename GetDistributionConfigurationRequestT = Model::GetDistributionConfigurationRequest>
        Model::GetDistributionConfigurationOutcomeCallable GetDistributionConfigurationCallable(const GetDistributionConfigurationRequestT& request) const
        {
            return SubmitCallable(&ImagebuilderClient::GetDistributionConfiguration, request);
        }
 
        template<typename GetDistributionConfigurationRequestT = Model::GetDistributionConfigurationRequest>
        void GetDistributionConfigurationAsync(const GetDistributionConfigurationRequestT& request, const GetDistributionConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ImagebuilderClient::GetDistributionConfiguration, request, handler, context);
        }
 
        virtual Model::GetImageOutcome GetImage(const Model::GetImageRequest& request) const;
 
        template<typename GetImageRequestT = Model::GetImageRequest>
        Model::GetImageOutcomeCallable GetImageCallable(const GetImageRequestT& request) const
        {
            return SubmitCallable(&ImagebuilderClient::GetImage, request);
        }
 
        template<typename GetImageRequestT = Model::GetImageRequest>
        void GetImageAsync(const GetImageRequestT& request, const GetImageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ImagebuilderClient::GetImage, request, handler, context);
        }
 
        virtual Model::GetImagePipelineOutcome GetImagePipeline(const Model::GetImagePipelineRequest& request) const;
 
        template<typename GetImagePipelineRequestT = Model::GetImagePipelineRequest>
        Model::GetImagePipelineOutcomeCallable GetImagePipelineCallable(const GetImagePipelineRequestT& request) const
        {
            return SubmitCallable(&ImagebuilderClient::GetImagePipeline, request);
        }
 
        template<typename GetImagePipelineRequestT = Model::GetImagePipelineRequest>
        void GetImagePipelineAsync(const GetImagePipelineRequestT& request, const GetImagePipelineResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ImagebuilderClient::GetImagePipeline, request, handler, context);
        }
 
        virtual Model::GetImagePolicyOutcome GetImagePolicy(const Model::GetImagePolicyRequest& request) const;
 
        template<typename GetImagePolicyRequestT = Model::GetImagePolicyRequest>
        Model::GetImagePolicyOutcomeCallable GetImagePolicyCallable(const GetImagePolicyRequestT& request) const
        {
            return SubmitCallable(&ImagebuilderClient::GetImagePolicy, request);
        }
 
        template<typename GetImagePolicyRequestT = Model::GetImagePolicyRequest>
        void GetImagePolicyAsync(const GetImagePolicyRequestT& request, const GetImagePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ImagebuilderClient::GetImagePolicy, request, handler, context);
        }
 
        virtual Model::GetImageRecipeOutcome GetImageRecipe(const Model::GetImageRecipeRequest& request) const;
 
        template<typename GetImageRecipeRequestT = Model::GetImageRecipeRequest>
        Model::GetImageRecipeOutcomeCallable GetImageRecipeCallable(const GetImageRecipeRequestT& request) const
        {
            return SubmitCallable(&ImagebuilderClient::GetImageRecipe, request);
        }
 
        template<typename GetImageRecipeRequestT = Model::GetImageRecipeRequest>
        void GetImageRecipeAsync(const GetImageRecipeRequestT& request, const GetImageRecipeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ImagebuilderClient::GetImageRecipe, request, handler, context);
        }
 
        virtual Model::GetImageRecipePolicyOutcome GetImageRecipePolicy(const Model::GetImageRecipePolicyRequest& request) const;
 
        template<typename GetImageRecipePolicyRequestT = Model::GetImageRecipePolicyRequest>
        Model::GetImageRecipePolicyOutcomeCallable GetImageRecipePolicyCallable(const GetImageRecipePolicyRequestT& request) const
        {
            return SubmitCallable(&ImagebuilderClient::GetImageRecipePolicy, request);
        }
 
        template<typename GetImageRecipePolicyRequestT = Model::GetImageRecipePolicyRequest>
        void GetImageRecipePolicyAsync(const GetImageRecipePolicyRequestT& request, const GetImageRecipePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ImagebuilderClient::GetImageRecipePolicy, request, handler, context);
        }
 
        virtual Model::GetInfrastructureConfigurationOutcome GetInfrastructureConfiguration(const Model::GetInfrastructureConfigurationRequest& request) const;
 
        template<typename GetInfrastructureConfigurationRequestT = Model::GetInfrastructureConfigurationRequest>
        Model::GetInfrastructureConfigurationOutcomeCallable GetInfrastructureConfigurationCallable(const GetInfrastructureConfigurationRequestT& request) const
        {
            return SubmitCallable(&ImagebuilderClient::GetInfrastructureConfiguration, request);
        }
 
        template<typename GetInfrastructureConfigurationRequestT = Model::GetInfrastructureConfigurationRequest>
        void GetInfrastructureConfigurationAsync(const GetInfrastructureConfigurationRequestT& request, const GetInfrastructureConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ImagebuilderClient::GetInfrastructureConfiguration, request, handler, context);
        }
 
        virtual Model::GetLifecycleExecutionOutcome GetLifecycleExecution(const Model::GetLifecycleExecutionRequest& request) const;
 
        template<typename GetLifecycleExecutionRequestT = Model::GetLifecycleExecutionRequest>
        Model::GetLifecycleExecutionOutcomeCallable GetLifecycleExecutionCallable(const GetLifecycleExecutionRequestT& request) const
        {
            return SubmitCallable(&ImagebuilderClient::GetLifecycleExecution, request);
        }
 
        template<typename GetLifecycleExecutionRequestT = Model::GetLifecycleExecutionRequest>
        void GetLifecycleExecutionAsync(const GetLifecycleExecutionRequestT& request, const GetLifecycleExecutionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ImagebuilderClient::GetLifecycleExecution, request, handler, context);
        }
 
        virtual Model::GetLifecyclePolicyOutcome GetLifecyclePolicy(const Model::GetLifecyclePolicyRequest& request) const;
 
        template<typename GetLifecyclePolicyRequestT = Model::GetLifecyclePolicyRequest>
        Model::GetLifecyclePolicyOutcomeCallable GetLifecyclePolicyCallable(const GetLifecyclePolicyRequestT& request) const
        {
            return SubmitCallable(&ImagebuilderClient::GetLifecyclePolicy, request);
        }
 
        template<typename GetLifecyclePolicyRequestT = Model::GetLifecyclePolicyRequest>
        void GetLifecyclePolicyAsync(const GetLifecyclePolicyRequestT& request, const GetLifecyclePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ImagebuilderClient::GetLifecyclePolicy, request, handler, context);
        }
 
        virtual Model::GetMarketplaceResourceOutcome GetMarketplaceResource(const Model::GetMarketplaceResourceRequest& request) const;
 
        template<typename GetMarketplaceResourceRequestT = Model::GetMarketplaceResourceRequest>
        Model::GetMarketplaceResourceOutcomeCallable GetMarketplaceResourceCallable(const GetMarketplaceResourceRequestT& request) const
        {
            return SubmitCallable(&ImagebuilderClient::GetMarketplaceResource, request);
        }
 
        template<typename GetMarketplaceResourceRequestT = Model::GetMarketplaceResourceRequest>
        void GetMarketplaceResourceAsync(const GetMarketplaceResourceRequestT& request, const GetMarketplaceResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ImagebuilderClient::GetMarketplaceResource, request, handler, context);
        }
 
        virtual Model::GetWorkflowOutcome GetWorkflow(const Model::GetWorkflowRequest& request) const;
 
        template<typename GetWorkflowRequestT = Model::GetWorkflowRequest>
        Model::GetWorkflowOutcomeCallable GetWorkflowCallable(const GetWorkflowRequestT& request) const
        {
            return SubmitCallable(&ImagebuilderClient::GetWorkflow, request);
        }
 
        template<typename GetWorkflowRequestT = Model::GetWorkflowRequest>
        void GetWorkflowAsync(const GetWorkflowRequestT& request, const GetWorkflowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ImagebuilderClient::GetWorkflow, request, handler, context);
        }
 
        virtual Model::GetWorkflowExecutionOutcome GetWorkflowExecution(const Model::GetWorkflowExecutionRequest& request) const;
 
        template<typename GetWorkflowExecutionRequestT = Model::GetWorkflowExecutionRequest>
        Model::GetWorkflowExecutionOutcomeCallable GetWorkflowExecutionCallable(const GetWorkflowExecutionRequestT& request) const
        {
            return SubmitCallable(&ImagebuilderClient::GetWorkflowExecution, request);
        }
 
        template<typename GetWorkflowExecutionRequestT = Model::GetWorkflowExecutionRequest>
        void GetWorkflowExecutionAsync(const GetWorkflowExecutionRequestT& request, const GetWorkflowExecutionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ImagebuilderClient::GetWorkflowExecution, request, handler, context);
        }
 
        virtual Model::GetWorkflowStepExecutionOutcome GetWorkflowStepExecution(const Model::GetWorkflowStepExecutionRequest& request) const;
 
        template<typename GetWorkflowStepExecutionRequestT = Model::GetWorkflowStepExecutionRequest>
        Model::GetWorkflowStepExecutionOutcomeCallable GetWorkflowStepExecutionCallable(const GetWorkflowStepExecutionRequestT& request) const
        {
            return SubmitCallable(&ImagebuilderClient::GetWorkflowStepExecution, request);
        }
 
        template<typename GetWorkflowStepExecutionRequestT = Model::GetWorkflowStepExecutionRequest>
        void GetWorkflowStepExecutionAsync(const GetWorkflowStepExecutionRequestT& request, const GetWorkflowStepExecutionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ImagebuilderClient::GetWorkflowStepExecution, request, handler, context);
        }
 
        virtual Model::ImportComponentOutcome ImportComponent(const Model::ImportComponentRequest& request) const;
 
        template<typename ImportComponentRequestT = Model::ImportComponentRequest>
        Model::ImportComponentOutcomeCallable ImportComponentCallable(const ImportComponentRequestT& request) const
        {
            return SubmitCallable(&ImagebuilderClient::ImportComponent, request);
        }
 
        template<typename ImportComponentRequestT = Model::ImportComponentRequest>
        void ImportComponentAsync(const ImportComponentRequestT& request, const ImportComponentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ImagebuilderClient::ImportComponent, request, handler, context);
        }
 
        virtual Model::ImportDiskImageOutcome ImportDiskImage(const Model::ImportDiskImageRequest& request) const;
 
        template<typename ImportDiskImageRequestT = Model::ImportDiskImageRequest>
        Model::ImportDiskImageOutcomeCallable ImportDiskImageCallable(const ImportDiskImageRequestT& request) const
        {
            return SubmitCallable(&ImagebuilderClient::ImportDiskImage, request);
        }
 
        template<typename ImportDiskImageRequestT = Model::ImportDiskImageRequest>
        void ImportDiskImageAsync(const ImportDiskImageRequestT& request, const ImportDiskImageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ImagebuilderClient::ImportDiskImage, request, handler, context);
        }
 
        virtual Model::ImportVmImageOutcome ImportVmImage(const Model::ImportVmImageRequest& request) const;
 
        template<typename ImportVmImageRequestT = Model::ImportVmImageRequest>
        Model::ImportVmImageOutcomeCallable ImportVmImageCallable(const ImportVmImageRequestT& request) const
        {
            return SubmitCallable(&ImagebuilderClient::ImportVmImage, request);
        }
 
        template<typename ImportVmImageRequestT = Model::ImportVmImageRequest>
        void ImportVmImageAsync(const ImportVmImageRequestT& request, const ImportVmImageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ImagebuilderClient::ImportVmImage, request, handler, context);
        }
 
        virtual Model::ListComponentBuildVersionsOutcome ListComponentBuildVersions(const Model::ListComponentBuildVersionsRequest& request) const;
 
        template<typename ListComponentBuildVersionsRequestT = Model::ListComponentBuildVersionsRequest>
        Model::ListComponentBuildVersionsOutcomeCallable ListComponentBuildVersionsCallable(const ListComponentBuildVersionsRequestT& request) const
        {
            return SubmitCallable(&ImagebuilderClient::ListComponentBuildVersions, request);
        }
 
        template<typename ListComponentBuildVersionsRequestT = Model::ListComponentBuildVersionsRequest>
        void ListComponentBuildVersionsAsync(const ListComponentBuildVersionsRequestT& request, const ListComponentBuildVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ImagebuilderClient::ListComponentBuildVersions, request, handler, context);
        }
 
        virtual Model::ListComponentsOutcome ListComponents(const Model::ListComponentsRequest& request = {}) const;
 
        template<typename ListComponentsRequestT = Model::ListComponentsRequest>
        Model::ListComponentsOutcomeCallable ListComponentsCallable(const ListComponentsRequestT& request = {}) const
        {
            return SubmitCallable(&ImagebuilderClient::ListComponents, request);
        }
 
        template<typename ListComponentsRequestT = Model::ListComponentsRequest>
        void ListComponentsAsync(const ListComponentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListComponentsRequestT& request = {}) const
        {
            return SubmitAsync(&ImagebuilderClient::ListComponents, request, handler, context);
        }
 
        virtual Model::ListContainerRecipesOutcome ListContainerRecipes(const Model::ListContainerRecipesRequest& request = {}) const;
 
        template<typename ListContainerRecipesRequestT = Model::ListContainerRecipesRequest>
        Model::ListContainerRecipesOutcomeCallable ListContainerRecipesCallable(const ListContainerRecipesRequestT& request = {}) const
        {
            return SubmitCallable(&ImagebuilderClient::ListContainerRecipes, request);
        }
 
        template<typename ListContainerRecipesRequestT = Model::ListContainerRecipesRequest>
        void ListContainerRecipesAsync(const ListContainerRecipesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListContainerRecipesRequestT& request = {}) const
        {
            return SubmitAsync(&ImagebuilderClient::ListContainerRecipes, request, handler, context);
        }
 
        virtual Model::ListDistributionConfigurationsOutcome ListDistributionConfigurations(const Model::ListDistributionConfigurationsRequest& request = {}) const;
 
        template<typename ListDistributionConfigurationsRequestT = Model::ListDistributionConfigurationsRequest>
        Model::ListDistributionConfigurationsOutcomeCallable ListDistributionConfigurationsCallable(const ListDistributionConfigurationsRequestT& request = {}) const
        {
            return SubmitCallable(&ImagebuilderClient::ListDistributionConfigurations, request);
        }
 
        template<typename ListDistributionConfigurationsRequestT = Model::ListDistributionConfigurationsRequest>
        void ListDistributionConfigurationsAsync(const ListDistributionConfigurationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListDistributionConfigurationsRequestT& request = {}) const
        {
            return SubmitAsync(&ImagebuilderClient::ListDistributionConfigurations, request, handler, context);
        }
 
        virtual Model::ListImageBuildVersionsOutcome ListImageBuildVersions(const Model::ListImageBuildVersionsRequest& request) const;
 
        template<typename ListImageBuildVersionsRequestT = Model::ListImageBuildVersionsRequest>
        Model::ListImageBuildVersionsOutcomeCallable ListImageBuildVersionsCallable(const ListImageBuildVersionsRequestT& request) const
        {
            return SubmitCallable(&ImagebuilderClient::ListImageBuildVersions, request);
        }
 
        template<typename ListImageBuildVersionsRequestT = Model::ListImageBuildVersionsRequest>
        void ListImageBuildVersionsAsync(const ListImageBuildVersionsRequestT& request, const ListImageBuildVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ImagebuilderClient::ListImageBuildVersions, request, handler, context);
        }
 
        virtual Model::ListImagePackagesOutcome ListImagePackages(const Model::ListImagePackagesRequest& request) const;
 
        template<typename ListImagePackagesRequestT = Model::ListImagePackagesRequest>
        Model::ListImagePackagesOutcomeCallable ListImagePackagesCallable(const ListImagePackagesRequestT& request) const
        {
            return SubmitCallable(&ImagebuilderClient::ListImagePackages, request);
        }
 
        template<typename ListImagePackagesRequestT = Model::ListImagePackagesRequest>
        void ListImagePackagesAsync(const ListImagePackagesRequestT& request, const ListImagePackagesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ImagebuilderClient::ListImagePackages, request, handler, context);
        }
 
        virtual Model::ListImagePipelineImagesOutcome ListImagePipelineImages(const Model::ListImagePipelineImagesRequest& request) const;
 
        template<typename ListImagePipelineImagesRequestT = Model::ListImagePipelineImagesRequest>
        Model::ListImagePipelineImagesOutcomeCallable ListImagePipelineImagesCallable(const ListImagePipelineImagesRequestT& request) const
        {
            return SubmitCallable(&ImagebuilderClient::ListImagePipelineImages, request);
        }
 
        template<typename ListImagePipelineImagesRequestT = Model::ListImagePipelineImagesRequest>
        void ListImagePipelineImagesAsync(const ListImagePipelineImagesRequestT& request, const ListImagePipelineImagesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ImagebuilderClient::ListImagePipelineImages, request, handler, context);
        }
 
        virtual Model::ListImagePipelinesOutcome ListImagePipelines(const Model::ListImagePipelinesRequest& request = {}) const;
 
        template<typename ListImagePipelinesRequestT = Model::ListImagePipelinesRequest>
        Model::ListImagePipelinesOutcomeCallable ListImagePipelinesCallable(const ListImagePipelinesRequestT& request = {}) const
        {
            return SubmitCallable(&ImagebuilderClient::ListImagePipelines, request);
        }
 
        template<typename ListImagePipelinesRequestT = Model::ListImagePipelinesRequest>
        void ListImagePipelinesAsync(const ListImagePipelinesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListImagePipelinesRequestT& request = {}) const
        {
            return SubmitAsync(&ImagebuilderClient::ListImagePipelines, request, handler, context);
        }
 
        virtual Model::ListImageRecipesOutcome ListImageRecipes(const Model::ListImageRecipesRequest& request = {}) const;
 
        template<typename ListImageRecipesRequestT = Model::ListImageRecipesRequest>
        Model::ListImageRecipesOutcomeCallable ListImageRecipesCallable(const ListImageRecipesRequestT& request = {}) const
        {
            return SubmitCallable(&ImagebuilderClient::ListImageRecipes, request);
        }
 
        template<typename ListImageRecipesRequestT = Model::ListImageRecipesRequest>
        void ListImageRecipesAsync(const ListImageRecipesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListImageRecipesRequestT& request = {}) const
        {
            return SubmitAsync(&ImagebuilderClient::ListImageRecipes, request, handler, context);
        }
 
        virtual Model::ListImageScanFindingAggregationsOutcome ListImageScanFindingAggregations(const Model::ListImageScanFindingAggregationsRequest& request = {}) const;
 
        template<typename ListImageScanFindingAggregationsRequestT = Model::ListImageScanFindingAggregationsRequest>
        Model::ListImageScanFindingAggregationsOutcomeCallable ListImageScanFindingAggregationsCallable(const ListImageScanFindingAggregationsRequestT& request = {}) const
        {
            return SubmitCallable(&ImagebuilderClient::ListImageScanFindingAggregations, request);
        }
 
        template<typename ListImageScanFindingAggregationsRequestT = Model::ListImageScanFindingAggregationsRequest>
        void ListImageScanFindingAggregationsAsync(const ListImageScanFindingAggregationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListImageScanFindingAggregationsRequestT& request = {}) const
        {
            return SubmitAsync(&ImagebuilderClient::ListImageScanFindingAggregations, request, handler, context);
        }
 
        virtual Model::ListImageScanFindingsOutcome ListImageScanFindings(const Model::ListImageScanFindingsRequest& request = {}) const;
 
        template<typename ListImageScanFindingsRequestT = Model::ListImageScanFindingsRequest>
        Model::ListImageScanFindingsOutcomeCallable ListImageScanFindingsCallable(const ListImageScanFindingsRequestT& request = {}) const
        {
            return SubmitCallable(&ImagebuilderClient::ListImageScanFindings, request);
        }
 
        template<typename ListImageScanFindingsRequestT = Model::ListImageScanFindingsRequest>
        void ListImageScanFindingsAsync(const ListImageScanFindingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListImageScanFindingsRequestT& request = {}) const
        {
            return SubmitAsync(&ImagebuilderClient::ListImageScanFindings, request, handler, context);
        }
 
        virtual Model::ListImagesOutcome ListImages(const Model::ListImagesRequest& request = {}) const;
 
        template<typename ListImagesRequestT = Model::ListImagesRequest>
        Model::ListImagesOutcomeCallable ListImagesCallable(const ListImagesRequestT& request = {}) const
        {
            return SubmitCallable(&ImagebuilderClient::ListImages, request);
        }
 
        template<typename ListImagesRequestT = Model::ListImagesRequest>
        void ListImagesAsync(const ListImagesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListImagesRequestT& request = {}) const
        {
            return SubmitAsync(&ImagebuilderClient::ListImages, request, handler, context);
        }
 
        virtual Model::ListInfrastructureConfigurationsOutcome ListInfrastructureConfigurations(const Model::ListInfrastructureConfigurationsRequest& request = {}) const;
 
        template<typename ListInfrastructureConfigurationsRequestT = Model::ListInfrastructureConfigurationsRequest>
        Model::ListInfrastructureConfigurationsOutcomeCallable ListInfrastructureConfigurationsCallable(const ListInfrastructureConfigurationsRequestT& request = {}) const
        {
            return SubmitCallable(&ImagebuilderClient::ListInfrastructureConfigurations, request);
        }
 
        template<typename ListInfrastructureConfigurationsRequestT = Model::ListInfrastructureConfigurationsRequest>
        void ListInfrastructureConfigurationsAsync(const ListInfrastructureConfigurationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListInfrastructureConfigurationsRequestT& request = {}) const
        {
            return SubmitAsync(&ImagebuilderClient::ListInfrastructureConfigurations, request, handler, context);
        }
 
        virtual Model::ListLifecycleExecutionResourcesOutcome ListLifecycleExecutionResources(const Model::ListLifecycleExecutionResourcesRequest& request) const;
 
        template<typename ListLifecycleExecutionResourcesRequestT = Model::ListLifecycleExecutionResourcesRequest>
        Model::ListLifecycleExecutionResourcesOutcomeCallable ListLifecycleExecutionResourcesCallable(const ListLifecycleExecutionResourcesRequestT& request) const
        {
            return SubmitCallable(&ImagebuilderClient::ListLifecycleExecutionResources, request);
        }
 
        template<typename ListLifecycleExecutionResourcesRequestT = Model::ListLifecycleExecutionResourcesRequest>
        void ListLifecycleExecutionResourcesAsync(const ListLifecycleExecutionResourcesRequestT& request, const ListLifecycleExecutionResourcesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ImagebuilderClient::ListLifecycleExecutionResources, request, handler, context);
        }
 
        virtual Model::ListLifecycleExecutionsOutcome ListLifecycleExecutions(const Model::ListLifecycleExecutionsRequest& request) const;
 
        template<typename ListLifecycleExecutionsRequestT = Model::ListLifecycleExecutionsRequest>
        Model::ListLifecycleExecutionsOutcomeCallable ListLifecycleExecutionsCallable(const ListLifecycleExecutionsRequestT& request) const
        {
            return SubmitCallable(&ImagebuilderClient::ListLifecycleExecutions, request);
        }
 
        template<typename ListLifecycleExecutionsRequestT = Model::ListLifecycleExecutionsRequest>
        void ListLifecycleExecutionsAsync(const ListLifecycleExecutionsRequestT& request, const ListLifecycleExecutionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ImagebuilderClient::ListLifecycleExecutions, request, handler, context);
        }
 
        virtual Model::ListLifecyclePoliciesOutcome ListLifecyclePolicies(const Model::ListLifecyclePoliciesRequest& request = {}) const;
 
        template<typename ListLifecyclePoliciesRequestT = Model::ListLifecyclePoliciesRequest>
        Model::ListLifecyclePoliciesOutcomeCallable ListLifecyclePoliciesCallable(const ListLifecyclePoliciesRequestT& request = {}) const
        {
            return SubmitCallable(&ImagebuilderClient::ListLifecyclePolicies, request);
        }
 
        template<typename ListLifecyclePoliciesRequestT = Model::ListLifecyclePoliciesRequest>
        void ListLifecyclePoliciesAsync(const ListLifecyclePoliciesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListLifecyclePoliciesRequestT& request = {}) const
        {
            return SubmitAsync(&ImagebuilderClient::ListLifecyclePolicies, 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(&ImagebuilderClient::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(&ImagebuilderClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::ListWaitingWorkflowStepsOutcome ListWaitingWorkflowSteps(const Model::ListWaitingWorkflowStepsRequest& request = {}) const;
 
        template<typename ListWaitingWorkflowStepsRequestT = Model::ListWaitingWorkflowStepsRequest>
        Model::ListWaitingWorkflowStepsOutcomeCallable ListWaitingWorkflowStepsCallable(const ListWaitingWorkflowStepsRequestT& request = {}) const
        {
            return SubmitCallable(&ImagebuilderClient::ListWaitingWorkflowSteps, request);
        }
 
        template<typename ListWaitingWorkflowStepsRequestT = Model::ListWaitingWorkflowStepsRequest>
        void ListWaitingWorkflowStepsAsync(const ListWaitingWorkflowStepsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListWaitingWorkflowStepsRequestT& request = {}) const
        {
            return SubmitAsync(&ImagebuilderClient::ListWaitingWorkflowSteps, request, handler, context);
        }
 
        virtual Model::ListWorkflowBuildVersionsOutcome ListWorkflowBuildVersions(const Model::ListWorkflowBuildVersionsRequest& request) const;
 
        template<typename ListWorkflowBuildVersionsRequestT = Model::ListWorkflowBuildVersionsRequest>
        Model::ListWorkflowBuildVersionsOutcomeCallable ListWorkflowBuildVersionsCallable(const ListWorkflowBuildVersionsRequestT& request) const
        {
            return SubmitCallable(&ImagebuilderClient::ListWorkflowBuildVersions, request);
        }
 
        template<typename ListWorkflowBuildVersionsRequestT = Model::ListWorkflowBuildVersionsRequest>
        void ListWorkflowBuildVersionsAsync(const ListWorkflowBuildVersionsRequestT& request, const ListWorkflowBuildVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ImagebuilderClient::ListWorkflowBuildVersions, request, handler, context);
        }
 
        virtual Model::ListWorkflowExecutionsOutcome ListWorkflowExecutions(const Model::ListWorkflowExecutionsRequest& request) const;
 
        template<typename ListWorkflowExecutionsRequestT = Model::ListWorkflowExecutionsRequest>
        Model::ListWorkflowExecutionsOutcomeCallable ListWorkflowExecutionsCallable(const ListWorkflowExecutionsRequestT& request) const
        {
            return SubmitCallable(&ImagebuilderClient::ListWorkflowExecutions, request);
        }
 
        template<typename ListWorkflowExecutionsRequestT = Model::ListWorkflowExecutionsRequest>
        void ListWorkflowExecutionsAsync(const ListWorkflowExecutionsRequestT& request, const ListWorkflowExecutionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ImagebuilderClient::ListWorkflowExecutions, request, handler, context);
        }
 
        virtual Model::ListWorkflowStepExecutionsOutcome ListWorkflowStepExecutions(const Model::ListWorkflowStepExecutionsRequest& request) const;
 
        template<typename ListWorkflowStepExecutionsRequestT = Model::ListWorkflowStepExecutionsRequest>
        Model::ListWorkflowStepExecutionsOutcomeCallable ListWorkflowStepExecutionsCallable(const ListWorkflowStepExecutionsRequestT& request) const
        {
            return SubmitCallable(&ImagebuilderClient::ListWorkflowStepExecutions, request);
        }
 
        template<typename ListWorkflowStepExecutionsRequestT = Model::ListWorkflowStepExecutionsRequest>
        void ListWorkflowStepExecutionsAsync(const ListWorkflowStepExecutionsRequestT& request, const ListWorkflowStepExecutionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ImagebuilderClient::ListWorkflowStepExecutions, request, handler, context);
        }
 
        virtual Model::ListWorkflowsOutcome ListWorkflows(const Model::ListWorkflowsRequest& request = {}) const;
 
        template<typename ListWorkflowsRequestT = Model::ListWorkflowsRequest>
        Model::ListWorkflowsOutcomeCallable ListWorkflowsCallable(const ListWorkflowsRequestT& request = {}) const
        {
            return SubmitCallable(&ImagebuilderClient::ListWorkflows, request);
        }
 
        template<typename ListWorkflowsRequestT = Model::ListWorkflowsRequest>
        void ListWorkflowsAsync(const ListWorkflowsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListWorkflowsRequestT& request = {}) const
        {
            return SubmitAsync(&ImagebuilderClient::ListWorkflows, request, handler, context);
        }
 
        virtual Model::PutComponentPolicyOutcome PutComponentPolicy(const Model::PutComponentPolicyRequest& request) const;
 
        template<typename PutComponentPolicyRequestT = Model::PutComponentPolicyRequest>
        Model::PutComponentPolicyOutcomeCallable PutComponentPolicyCallable(const PutComponentPolicyRequestT& request) const
        {
            return SubmitCallable(&ImagebuilderClient::PutComponentPolicy, request);
        }
 
        template<typename PutComponentPolicyRequestT = Model::PutComponentPolicyRequest>
        void PutComponentPolicyAsync(const PutComponentPolicyRequestT& request, const PutComponentPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ImagebuilderClient::PutComponentPolicy, request, handler, context);
        }
 
        virtual Model::PutContainerRecipePolicyOutcome PutContainerRecipePolicy(const Model::PutContainerRecipePolicyRequest& request) const;
 
        template<typename PutContainerRecipePolicyRequestT = Model::PutContainerRecipePolicyRequest>
        Model::PutContainerRecipePolicyOutcomeCallable PutContainerRecipePolicyCallable(const PutContainerRecipePolicyRequestT& request) const
        {
            return SubmitCallable(&ImagebuilderClient::PutContainerRecipePolicy, request);
        }
 
        template<typename PutContainerRecipePolicyRequestT = Model::PutContainerRecipePolicyRequest>
        void PutContainerRecipePolicyAsync(const PutContainerRecipePolicyRequestT& request, const PutContainerRecipePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ImagebuilderClient::PutContainerRecipePolicy, request, handler, context);
        }
 
        virtual Model::PutImagePolicyOutcome PutImagePolicy(const Model::PutImagePolicyRequest& request) const;
 
        template<typename PutImagePolicyRequestT = Model::PutImagePolicyRequest>
        Model::PutImagePolicyOutcomeCallable PutImagePolicyCallable(const PutImagePolicyRequestT& request) const
        {
            return SubmitCallable(&ImagebuilderClient::PutImagePolicy, request);
        }
 
        template<typename PutImagePolicyRequestT = Model::PutImagePolicyRequest>
        void PutImagePolicyAsync(const PutImagePolicyRequestT& request, const PutImagePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ImagebuilderClient::PutImagePolicy, request, handler, context);
        }
 
        virtual Model::PutImageRecipePolicyOutcome PutImageRecipePolicy(const Model::PutImageRecipePolicyRequest& request) const;
 
        template<typename PutImageRecipePolicyRequestT = Model::PutImageRecipePolicyRequest>
        Model::PutImageRecipePolicyOutcomeCallable PutImageRecipePolicyCallable(const PutImageRecipePolicyRequestT& request) const
        {
            return SubmitCallable(&ImagebuilderClient::PutImageRecipePolicy, request);
        }
 
        template<typename PutImageRecipePolicyRequestT = Model::PutImageRecipePolicyRequest>
        void PutImageRecipePolicyAsync(const PutImageRecipePolicyRequestT& request, const PutImageRecipePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ImagebuilderClient::PutImageRecipePolicy, request, handler, context);
        }
 
        virtual Model::SendWorkflowStepActionOutcome SendWorkflowStepAction(const Model::SendWorkflowStepActionRequest& request) const;
 
        template<typename SendWorkflowStepActionRequestT = Model::SendWorkflowStepActionRequest>
        Model::SendWorkflowStepActionOutcomeCallable SendWorkflowStepActionCallable(const SendWorkflowStepActionRequestT& request) const
        {
            return SubmitCallable(&ImagebuilderClient::SendWorkflowStepAction, request);
        }
 
        template<typename SendWorkflowStepActionRequestT = Model::SendWorkflowStepActionRequest>
        void SendWorkflowStepActionAsync(const SendWorkflowStepActionRequestT& request, const SendWorkflowStepActionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ImagebuilderClient::SendWorkflowStepAction, request, handler, context);
        }
 
        virtual Model::StartImagePipelineExecutionOutcome StartImagePipelineExecution(const Model::StartImagePipelineExecutionRequest& request) const;
 
        template<typename StartImagePipelineExecutionRequestT = Model::StartImagePipelineExecutionRequest>
        Model::StartImagePipelineExecutionOutcomeCallable StartImagePipelineExecutionCallable(const StartImagePipelineExecutionRequestT& request) const
        {
            return SubmitCallable(&ImagebuilderClient::StartImagePipelineExecution, request);
        }
 
        template<typename StartImagePipelineExecutionRequestT = Model::StartImagePipelineExecutionRequest>
        void StartImagePipelineExecutionAsync(const StartImagePipelineExecutionRequestT& request, const StartImagePipelineExecutionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ImagebuilderClient::StartImagePipelineExecution, request, handler, context);
        }
 
        virtual Model::StartResourceStateUpdateOutcome StartResourceStateUpdate(const Model::StartResourceStateUpdateRequest& request) const;
 
        template<typename StartResourceStateUpdateRequestT = Model::StartResourceStateUpdateRequest>
        Model::StartResourceStateUpdateOutcomeCallable StartResourceStateUpdateCallable(const StartResourceStateUpdateRequestT& request) const
        {
            return SubmitCallable(&ImagebuilderClient::StartResourceStateUpdate, request);
        }
 
        template<typename StartResourceStateUpdateRequestT = Model::StartResourceStateUpdateRequest>
        void StartResourceStateUpdateAsync(const StartResourceStateUpdateRequestT& request, const StartResourceStateUpdateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ImagebuilderClient::StartResourceStateUpdate, 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(&ImagebuilderClient::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(&ImagebuilderClient::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(&ImagebuilderClient::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(&ImagebuilderClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateDistributionConfigurationOutcome UpdateDistributionConfiguration(const Model::UpdateDistributionConfigurationRequest& request) const;
 
        template<typename UpdateDistributionConfigurationRequestT = Model::UpdateDistributionConfigurationRequest>
        Model::UpdateDistributionConfigurationOutcomeCallable UpdateDistributionConfigurationCallable(const UpdateDistributionConfigurationRequestT& request) const
        {
            return SubmitCallable(&ImagebuilderClient::UpdateDistributionConfiguration, request);
        }
 
        template<typename UpdateDistributionConfigurationRequestT = Model::UpdateDistributionConfigurationRequest>
        void UpdateDistributionConfigurationAsync(const UpdateDistributionConfigurationRequestT& request, const UpdateDistributionConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ImagebuilderClient::UpdateDistributionConfiguration, request, handler, context);
        }
 
        virtual Model::UpdateImagePipelineOutcome UpdateImagePipeline(const Model::UpdateImagePipelineRequest& request) const;
 
        template<typename UpdateImagePipelineRequestT = Model::UpdateImagePipelineRequest>
        Model::UpdateImagePipelineOutcomeCallable UpdateImagePipelineCallable(const UpdateImagePipelineRequestT& request) const
        {
            return SubmitCallable(&ImagebuilderClient::UpdateImagePipeline, request);
        }
 
        template<typename UpdateImagePipelineRequestT = Model::UpdateImagePipelineRequest>
        void UpdateImagePipelineAsync(const UpdateImagePipelineRequestT& request, const UpdateImagePipelineResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ImagebuilderClient::UpdateImagePipeline, request, handler, context);
        }
 
        virtual Model::UpdateInfrastructureConfigurationOutcome UpdateInfrastructureConfiguration(const Model::UpdateInfrastructureConfigurationRequest& request) const;
 
        template<typename UpdateInfrastructureConfigurationRequestT = Model::UpdateInfrastructureConfigurationRequest>
        Model::UpdateInfrastructureConfigurationOutcomeCallable UpdateInfrastructureConfigurationCallable(const UpdateInfrastructureConfigurationRequestT& request) const
        {
            return SubmitCallable(&ImagebuilderClient::UpdateInfrastructureConfiguration, request);
        }
 
        template<typename UpdateInfrastructureConfigurationRequestT = Model::UpdateInfrastructureConfigurationRequest>
        void UpdateInfrastructureConfigurationAsync(const UpdateInfrastructureConfigurationRequestT& request, const UpdateInfrastructureConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ImagebuilderClient::UpdateInfrastructureConfiguration, request, handler, context);
        }
 
        virtual Model::UpdateLifecyclePolicyOutcome UpdateLifecyclePolicy(const Model::UpdateLifecyclePolicyRequest& request) const;
 
        template<typename UpdateLifecyclePolicyRequestT = Model::UpdateLifecyclePolicyRequest>
        Model::UpdateLifecyclePolicyOutcomeCallable UpdateLifecyclePolicyCallable(const UpdateLifecyclePolicyRequestT& request) const
        {
            return SubmitCallable(&ImagebuilderClient::UpdateLifecyclePolicy, request);
        }
 
        template<typename UpdateLifecyclePolicyRequestT = Model::UpdateLifecyclePolicyRequest>
        void UpdateLifecyclePolicyAsync(const UpdateLifecyclePolicyRequestT& request, const UpdateLifecyclePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ImagebuilderClient::UpdateLifecyclePolicy, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<ImagebuilderEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<ImagebuilderClient>;
      void init(const ImagebuilderClientConfiguration& clientConfiguration);
 
      ImagebuilderClientConfiguration m_clientConfiguration;
      std::shared_ptr<ImagebuilderEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace imagebuilder
} // namespace Aws