ImagebuilderClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/imagebuilder/ImagebuilderPaginationBase.h>
#include <aws/imagebuilder/ImagebuilderServiceClientModel.h>
#include <aws/imagebuilder/ImagebuilderWaiter.h>
#include <aws/imagebuilder/Imagebuilder_EXPORTS.h>
 
namespace Aws {
namespace imagebuilder {
class AWS_IMAGEBUILDER_API ImagebuilderClient : public Aws::Client::AWSJsonClient,
                                                public Aws::Client::ClientWithAsyncTemplateMethods<ImagebuilderClient>,
                                                public ImagebuilderPaginationBase<ImagebuilderClient>,
                                                public ImagebuilderWaiter<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::DistributeImageOutcome DistributeImage(const Model::DistributeImageRequest& request) const;
 
  template <typename DistributeImageRequestT = Model::DistributeImageRequest>
  Model::DistributeImageOutcomeCallable DistributeImageCallable(const DistributeImageRequestT& request) const {
    return SubmitCallable(&ImagebuilderClient::DistributeImage, request);
  }
 
  template <typename DistributeImageRequestT = Model::DistributeImageRequest>
  void DistributeImageAsync(const DistributeImageRequestT& request, const DistributeImageResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ImagebuilderClient::DistributeImage, 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 ListComponentBuildVersionsResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                       const ListComponentBuildVersionsRequestT& request = {}) 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 ListImageBuildVersionsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                   const ListImageBuildVersionsRequestT& request = {}) 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 ListWorkflowBuildVersionsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                      const ListWorkflowBuildVersionsRequestT& request = {}) 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::RetryImageOutcome RetryImage(const Model::RetryImageRequest& request) const;
 
  template <typename RetryImageRequestT = Model::RetryImageRequest>
  Model::RetryImageOutcomeCallable RetryImageCallable(const RetryImageRequestT& request) const {
    return SubmitCallable(&ImagebuilderClient::RetryImage, request);
  }
 
  template <typename RetryImageRequestT = Model::RetryImageRequest>
  void RetryImageAsync(const RetryImageRequestT& request, const RetryImageResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ImagebuilderClient::RetryImage, 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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<ImagebuilderEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<ImagebuilderClient>;
  void init(const ImagebuilderClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, ImagebuilderError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  ImagebuilderClientConfiguration m_clientConfiguration;
  std::shared_ptr<ImagebuilderEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace imagebuilder
}  // namespace Aws