LambdaMicrovmsClient.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/lambda-microvms/LambdaMicrovmsPaginationBase.h>
#include <aws/lambda-microvms/LambdaMicrovmsServiceClientModel.h>
#include <aws/lambda-microvms/LambdaMicrovmsWaiter.h>
#include <aws/lambda-microvms/LambdaMicrovms_EXPORTS.h>
 
namespace Aws {
namespace LambdaMicrovms {
class AWS_LAMBDAMICROVMS_API LambdaMicrovmsClient : public Aws::Client::AWSJsonClient,
                                                    public Aws::Client::ClientWithAsyncTemplateMethods<LambdaMicrovmsClient>,
                                                    public LambdaMicrovmsPaginationBase<LambdaMicrovmsClient>,
                                                    public LambdaMicrovmsWaiter<LambdaMicrovmsClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef LambdaMicrovmsClientConfiguration ClientConfigurationType;
  typedef LambdaMicrovmsEndpointProvider EndpointProviderType;
 
  LambdaMicrovmsClient(const Aws::LambdaMicrovms::LambdaMicrovmsClientConfiguration& clientConfiguration =
                           Aws::LambdaMicrovms::LambdaMicrovmsClientConfiguration(),
                       std::shared_ptr<LambdaMicrovmsEndpointProviderBase> endpointProvider = nullptr);
 
  LambdaMicrovmsClient(const Aws::Auth::AWSCredentials& credentials,
                       std::shared_ptr<LambdaMicrovmsEndpointProviderBase> endpointProvider = nullptr,
                       const Aws::LambdaMicrovms::LambdaMicrovmsClientConfiguration& clientConfiguration =
                           Aws::LambdaMicrovms::LambdaMicrovmsClientConfiguration());
 
  LambdaMicrovmsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                       std::shared_ptr<LambdaMicrovmsEndpointProviderBase> endpointProvider = nullptr,
                       const Aws::LambdaMicrovms::LambdaMicrovmsClientConfiguration& clientConfiguration =
                           Aws::LambdaMicrovms::LambdaMicrovmsClientConfiguration());
 
  /* Legacy constructors due deprecation */
  LambdaMicrovmsClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  LambdaMicrovmsClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  LambdaMicrovmsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                       const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~LambdaMicrovmsClient();
 
  virtual Model::CreateMicrovmAuthTokenOutcome CreateMicrovmAuthToken(const Model::CreateMicrovmAuthTokenRequest& request) const;
 
  template <typename CreateMicrovmAuthTokenRequestT = Model::CreateMicrovmAuthTokenRequest>
  Model::CreateMicrovmAuthTokenOutcomeCallable CreateMicrovmAuthTokenCallable(const CreateMicrovmAuthTokenRequestT& request) const {
    return SubmitCallable(&LambdaMicrovmsClient::CreateMicrovmAuthToken, request);
  }
 
  template <typename CreateMicrovmAuthTokenRequestT = Model::CreateMicrovmAuthTokenRequest>
  void CreateMicrovmAuthTokenAsync(const CreateMicrovmAuthTokenRequestT& request,
                                   const CreateMicrovmAuthTokenResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaMicrovmsClient::CreateMicrovmAuthToken, request, handler, context);
  }
 
  virtual Model::CreateMicrovmImageOutcome CreateMicrovmImage(const Model::CreateMicrovmImageRequest& request) const;
 
  template <typename CreateMicrovmImageRequestT = Model::CreateMicrovmImageRequest>
  Model::CreateMicrovmImageOutcomeCallable CreateMicrovmImageCallable(const CreateMicrovmImageRequestT& request) const {
    return SubmitCallable(&LambdaMicrovmsClient::CreateMicrovmImage, request);
  }
 
  template <typename CreateMicrovmImageRequestT = Model::CreateMicrovmImageRequest>
  void CreateMicrovmImageAsync(const CreateMicrovmImageRequestT& request, const CreateMicrovmImageResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaMicrovmsClient::CreateMicrovmImage, request, handler, context);
  }
 
  virtual Model::CreateMicrovmShellAuthTokenOutcome CreateMicrovmShellAuthToken(
      const Model::CreateMicrovmShellAuthTokenRequest& request) const;
 
  template <typename CreateMicrovmShellAuthTokenRequestT = Model::CreateMicrovmShellAuthTokenRequest>
  Model::CreateMicrovmShellAuthTokenOutcomeCallable CreateMicrovmShellAuthTokenCallable(
      const CreateMicrovmShellAuthTokenRequestT& request) const {
    return SubmitCallable(&LambdaMicrovmsClient::CreateMicrovmShellAuthToken, request);
  }
 
  template <typename CreateMicrovmShellAuthTokenRequestT = Model::CreateMicrovmShellAuthTokenRequest>
  void CreateMicrovmShellAuthTokenAsync(const CreateMicrovmShellAuthTokenRequestT& request,
                                        const CreateMicrovmShellAuthTokenResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaMicrovmsClient::CreateMicrovmShellAuthToken, request, handler, context);
  }
 
  virtual Model::DeleteMicrovmImageOutcome DeleteMicrovmImage(const Model::DeleteMicrovmImageRequest& request) const;
 
  template <typename DeleteMicrovmImageRequestT = Model::DeleteMicrovmImageRequest>
  Model::DeleteMicrovmImageOutcomeCallable DeleteMicrovmImageCallable(const DeleteMicrovmImageRequestT& request) const {
    return SubmitCallable(&LambdaMicrovmsClient::DeleteMicrovmImage, request);
  }
 
  template <typename DeleteMicrovmImageRequestT = Model::DeleteMicrovmImageRequest>
  void DeleteMicrovmImageAsync(const DeleteMicrovmImageRequestT& request, const DeleteMicrovmImageResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaMicrovmsClient::DeleteMicrovmImage, request, handler, context);
  }
 
  virtual Model::DeleteMicrovmImageVersionOutcome DeleteMicrovmImageVersion(const Model::DeleteMicrovmImageVersionRequest& request) const;
 
  template <typename DeleteMicrovmImageVersionRequestT = Model::DeleteMicrovmImageVersionRequest>
  Model::DeleteMicrovmImageVersionOutcomeCallable DeleteMicrovmImageVersionCallable(
      const DeleteMicrovmImageVersionRequestT& request) const {
    return SubmitCallable(&LambdaMicrovmsClient::DeleteMicrovmImageVersion, request);
  }
 
  template <typename DeleteMicrovmImageVersionRequestT = Model::DeleteMicrovmImageVersionRequest>
  void DeleteMicrovmImageVersionAsync(const DeleteMicrovmImageVersionRequestT& request,
                                      const DeleteMicrovmImageVersionResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaMicrovmsClient::DeleteMicrovmImageVersion, request, handler, context);
  }
 
  virtual Model::GetMicrovmOutcome GetMicrovm(const Model::GetMicrovmRequest& request) const;
 
  template <typename GetMicrovmRequestT = Model::GetMicrovmRequest>
  Model::GetMicrovmOutcomeCallable GetMicrovmCallable(const GetMicrovmRequestT& request) const {
    return SubmitCallable(&LambdaMicrovmsClient::GetMicrovm, request);
  }
 
  template <typename GetMicrovmRequestT = Model::GetMicrovmRequest>
  void GetMicrovmAsync(const GetMicrovmRequestT& request, const GetMicrovmResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaMicrovmsClient::GetMicrovm, request, handler, context);
  }
 
  virtual Model::GetMicrovmImageOutcome GetMicrovmImage(const Model::GetMicrovmImageRequest& request) const;
 
  template <typename GetMicrovmImageRequestT = Model::GetMicrovmImageRequest>
  Model::GetMicrovmImageOutcomeCallable GetMicrovmImageCallable(const GetMicrovmImageRequestT& request) const {
    return SubmitCallable(&LambdaMicrovmsClient::GetMicrovmImage, request);
  }
 
  template <typename GetMicrovmImageRequestT = Model::GetMicrovmImageRequest>
  void GetMicrovmImageAsync(const GetMicrovmImageRequestT& request, const GetMicrovmImageResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaMicrovmsClient::GetMicrovmImage, request, handler, context);
  }
 
  virtual Model::GetMicrovmImageBuildOutcome GetMicrovmImageBuild(const Model::GetMicrovmImageBuildRequest& request) const;
 
  template <typename GetMicrovmImageBuildRequestT = Model::GetMicrovmImageBuildRequest>
  Model::GetMicrovmImageBuildOutcomeCallable GetMicrovmImageBuildCallable(const GetMicrovmImageBuildRequestT& request) const {
    return SubmitCallable(&LambdaMicrovmsClient::GetMicrovmImageBuild, request);
  }
 
  template <typename GetMicrovmImageBuildRequestT = Model::GetMicrovmImageBuildRequest>
  void GetMicrovmImageBuildAsync(const GetMicrovmImageBuildRequestT& request, const GetMicrovmImageBuildResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaMicrovmsClient::GetMicrovmImageBuild, request, handler, context);
  }
 
  virtual Model::GetMicrovmImageVersionOutcome GetMicrovmImageVersion(const Model::GetMicrovmImageVersionRequest& request) const;
 
  template <typename GetMicrovmImageVersionRequestT = Model::GetMicrovmImageVersionRequest>
  Model::GetMicrovmImageVersionOutcomeCallable GetMicrovmImageVersionCallable(const GetMicrovmImageVersionRequestT& request) const {
    return SubmitCallable(&LambdaMicrovmsClient::GetMicrovmImageVersion, request);
  }
 
  template <typename GetMicrovmImageVersionRequestT = Model::GetMicrovmImageVersionRequest>
  void GetMicrovmImageVersionAsync(const GetMicrovmImageVersionRequestT& request,
                                   const GetMicrovmImageVersionResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaMicrovmsClient::GetMicrovmImageVersion, request, handler, context);
  }
 
  virtual Model::ListManagedMicrovmImageVersionsOutcome ListManagedMicrovmImageVersions(
      const Model::ListManagedMicrovmImageVersionsRequest& request) const;
 
  template <typename ListManagedMicrovmImageVersionsRequestT = Model::ListManagedMicrovmImageVersionsRequest>
  Model::ListManagedMicrovmImageVersionsOutcomeCallable ListManagedMicrovmImageVersionsCallable(
      const ListManagedMicrovmImageVersionsRequestT& request) const {
    return SubmitCallable(&LambdaMicrovmsClient::ListManagedMicrovmImageVersions, request);
  }
 
  template <typename ListManagedMicrovmImageVersionsRequestT = Model::ListManagedMicrovmImageVersionsRequest>
  void ListManagedMicrovmImageVersionsAsync(const ListManagedMicrovmImageVersionsRequestT& request,
                                            const ListManagedMicrovmImageVersionsResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaMicrovmsClient::ListManagedMicrovmImageVersions, request, handler, context);
  }
 
  virtual Model::ListManagedMicrovmImagesOutcome ListManagedMicrovmImages(const Model::ListManagedMicrovmImagesRequest& request = {}) const;
 
  template <typename ListManagedMicrovmImagesRequestT = Model::ListManagedMicrovmImagesRequest>
  Model::ListManagedMicrovmImagesOutcomeCallable ListManagedMicrovmImagesCallable(
      const ListManagedMicrovmImagesRequestT& request = {}) const {
    return SubmitCallable(&LambdaMicrovmsClient::ListManagedMicrovmImages, request);
  }
 
  template <typename ListManagedMicrovmImagesRequestT = Model::ListManagedMicrovmImagesRequest>
  void ListManagedMicrovmImagesAsync(const ListManagedMicrovmImagesResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const ListManagedMicrovmImagesRequestT& request = {}) const {
    return SubmitAsync(&LambdaMicrovmsClient::ListManagedMicrovmImages, request, handler, context);
  }
 
  virtual Model::ListMicrovmImageBuildsOutcome ListMicrovmImageBuilds(const Model::ListMicrovmImageBuildsRequest& request) const;
 
  template <typename ListMicrovmImageBuildsRequestT = Model::ListMicrovmImageBuildsRequest>
  Model::ListMicrovmImageBuildsOutcomeCallable ListMicrovmImageBuildsCallable(const ListMicrovmImageBuildsRequestT& request) const {
    return SubmitCallable(&LambdaMicrovmsClient::ListMicrovmImageBuilds, request);
  }
 
  template <typename ListMicrovmImageBuildsRequestT = Model::ListMicrovmImageBuildsRequest>
  void ListMicrovmImageBuildsAsync(const ListMicrovmImageBuildsRequestT& request,
                                   const ListMicrovmImageBuildsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaMicrovmsClient::ListMicrovmImageBuilds, request, handler, context);
  }
 
  virtual Model::ListMicrovmImageVersionsOutcome ListMicrovmImageVersions(const Model::ListMicrovmImageVersionsRequest& request) const;
 
  template <typename ListMicrovmImageVersionsRequestT = Model::ListMicrovmImageVersionsRequest>
  Model::ListMicrovmImageVersionsOutcomeCallable ListMicrovmImageVersionsCallable(const ListMicrovmImageVersionsRequestT& request) const {
    return SubmitCallable(&LambdaMicrovmsClient::ListMicrovmImageVersions, request);
  }
 
  template <typename ListMicrovmImageVersionsRequestT = Model::ListMicrovmImageVersionsRequest>
  void ListMicrovmImageVersionsAsync(const ListMicrovmImageVersionsRequestT& request,
                                     const ListMicrovmImageVersionsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaMicrovmsClient::ListMicrovmImageVersions, request, handler, context);
  }
 
  virtual Model::ListMicrovmImagesOutcome ListMicrovmImages(const Model::ListMicrovmImagesRequest& request = {}) const;
 
  template <typename ListMicrovmImagesRequestT = Model::ListMicrovmImagesRequest>
  Model::ListMicrovmImagesOutcomeCallable ListMicrovmImagesCallable(const ListMicrovmImagesRequestT& request = {}) const {
    return SubmitCallable(&LambdaMicrovmsClient::ListMicrovmImages, request);
  }
 
  template <typename ListMicrovmImagesRequestT = Model::ListMicrovmImagesRequest>
  void ListMicrovmImagesAsync(const ListMicrovmImagesResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const ListMicrovmImagesRequestT& request = {}) const {
    return SubmitAsync(&LambdaMicrovmsClient::ListMicrovmImages, request, handler, context);
  }
 
  virtual Model::ListMicrovmsOutcome ListMicrovms(const Model::ListMicrovmsRequest& request = {}) const;
 
  template <typename ListMicrovmsRequestT = Model::ListMicrovmsRequest>
  Model::ListMicrovmsOutcomeCallable ListMicrovmsCallable(const ListMicrovmsRequestT& request = {}) const {
    return SubmitCallable(&LambdaMicrovmsClient::ListMicrovms, request);
  }
 
  template <typename ListMicrovmsRequestT = Model::ListMicrovmsRequest>
  void ListMicrovmsAsync(const ListMicrovmsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const ListMicrovmsRequestT& request = {}) const {
    return SubmitAsync(&LambdaMicrovmsClient::ListMicrovms, request, handler, context);
  }
 
  virtual Model::ListTagsOutcome ListTags(const Model::ListTagsRequest& request) const;
 
  template <typename ListTagsRequestT = Model::ListTagsRequest>
  Model::ListTagsOutcomeCallable ListTagsCallable(const ListTagsRequestT& request) const {
    return SubmitCallable(&LambdaMicrovmsClient::ListTags, request);
  }
 
  template <typename ListTagsRequestT = Model::ListTagsRequest>
  void ListTagsAsync(const ListTagsRequestT& request, const ListTagsResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaMicrovmsClient::ListTags, request, handler, context);
  }
 
  virtual Model::ResumeMicrovmOutcome ResumeMicrovm(const Model::ResumeMicrovmRequest& request) const;
 
  template <typename ResumeMicrovmRequestT = Model::ResumeMicrovmRequest>
  Model::ResumeMicrovmOutcomeCallable ResumeMicrovmCallable(const ResumeMicrovmRequestT& request) const {
    return SubmitCallable(&LambdaMicrovmsClient::ResumeMicrovm, request);
  }
 
  template <typename ResumeMicrovmRequestT = Model::ResumeMicrovmRequest>
  void ResumeMicrovmAsync(const ResumeMicrovmRequestT& request, const ResumeMicrovmResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaMicrovmsClient::ResumeMicrovm, request, handler, context);
  }
 
  virtual Model::RunMicrovmOutcome RunMicrovm(const Model::RunMicrovmRequest& request) const;
 
  template <typename RunMicrovmRequestT = Model::RunMicrovmRequest>
  Model::RunMicrovmOutcomeCallable RunMicrovmCallable(const RunMicrovmRequestT& request) const {
    return SubmitCallable(&LambdaMicrovmsClient::RunMicrovm, request);
  }
 
  template <typename RunMicrovmRequestT = Model::RunMicrovmRequest>
  void RunMicrovmAsync(const RunMicrovmRequestT& request, const RunMicrovmResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaMicrovmsClient::RunMicrovm, request, handler, context);
  }
 
  virtual Model::SuspendMicrovmOutcome SuspendMicrovm(const Model::SuspendMicrovmRequest& request) const;
 
  template <typename SuspendMicrovmRequestT = Model::SuspendMicrovmRequest>
  Model::SuspendMicrovmOutcomeCallable SuspendMicrovmCallable(const SuspendMicrovmRequestT& request) const {
    return SubmitCallable(&LambdaMicrovmsClient::SuspendMicrovm, request);
  }
 
  template <typename SuspendMicrovmRequestT = Model::SuspendMicrovmRequest>
  void SuspendMicrovmAsync(const SuspendMicrovmRequestT& request, const SuspendMicrovmResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaMicrovmsClient::SuspendMicrovm, 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(&LambdaMicrovmsClient::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(&LambdaMicrovmsClient::TagResource, request, handler, context);
  }
 
  virtual Model::TerminateMicrovmOutcome TerminateMicrovm(const Model::TerminateMicrovmRequest& request) const;
 
  template <typename TerminateMicrovmRequestT = Model::TerminateMicrovmRequest>
  Model::TerminateMicrovmOutcomeCallable TerminateMicrovmCallable(const TerminateMicrovmRequestT& request) const {
    return SubmitCallable(&LambdaMicrovmsClient::TerminateMicrovm, request);
  }
 
  template <typename TerminateMicrovmRequestT = Model::TerminateMicrovmRequest>
  void TerminateMicrovmAsync(const TerminateMicrovmRequestT& request, const TerminateMicrovmResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaMicrovmsClient::TerminateMicrovm, 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(&LambdaMicrovmsClient::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(&LambdaMicrovmsClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateMicrovmImageOutcome UpdateMicrovmImage(const Model::UpdateMicrovmImageRequest& request) const;
 
  template <typename UpdateMicrovmImageRequestT = Model::UpdateMicrovmImageRequest>
  Model::UpdateMicrovmImageOutcomeCallable UpdateMicrovmImageCallable(const UpdateMicrovmImageRequestT& request) const {
    return SubmitCallable(&LambdaMicrovmsClient::UpdateMicrovmImage, request);
  }
 
  template <typename UpdateMicrovmImageRequestT = Model::UpdateMicrovmImageRequest>
  void UpdateMicrovmImageAsync(const UpdateMicrovmImageRequestT& request, const UpdateMicrovmImageResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaMicrovmsClient::UpdateMicrovmImage, request, handler, context);
  }
 
  virtual Model::UpdateMicrovmImageVersionOutcome UpdateMicrovmImageVersion(const Model::UpdateMicrovmImageVersionRequest& request) const;
 
  template <typename UpdateMicrovmImageVersionRequestT = Model::UpdateMicrovmImageVersionRequest>
  Model::UpdateMicrovmImageVersionOutcomeCallable UpdateMicrovmImageVersionCallable(
      const UpdateMicrovmImageVersionRequestT& request) const {
    return SubmitCallable(&LambdaMicrovmsClient::UpdateMicrovmImageVersion, request);
  }
 
  template <typename UpdateMicrovmImageVersionRequestT = Model::UpdateMicrovmImageVersionRequest>
  void UpdateMicrovmImageVersionAsync(const UpdateMicrovmImageVersionRequestT& request,
                                      const UpdateMicrovmImageVersionResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaMicrovmsClient::UpdateMicrovmImageVersion, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<LambdaMicrovmsEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<LambdaMicrovmsClient>;
  void init(const LambdaMicrovmsClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, LambdaMicrovmsError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  LambdaMicrovmsClientConfiguration m_clientConfiguration;
  std::shared_ptr<LambdaMicrovmsEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace LambdaMicrovms
}  // namespace Aws