LaunchWizardClient.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/launch-wizard/LaunchWizardServiceClientModel.h>
#include <aws/launch-wizard/LaunchWizard_EXPORTS.h>
 
namespace Aws {
namespace LaunchWizard {
class AWS_LAUNCHWIZARD_API LaunchWizardClient : public Aws::Client::AWSJsonClient,
                                                public Aws::Client::ClientWithAsyncTemplateMethods<LaunchWizardClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef LaunchWizardClientConfiguration ClientConfigurationType;
  typedef LaunchWizardEndpointProvider EndpointProviderType;
 
  LaunchWizardClient(
      const Aws::LaunchWizard::LaunchWizardClientConfiguration& clientConfiguration = Aws::LaunchWizard::LaunchWizardClientConfiguration(),
      std::shared_ptr<LaunchWizardEndpointProviderBase> endpointProvider = nullptr);
 
  LaunchWizardClient(
      const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<LaunchWizardEndpointProviderBase> endpointProvider = nullptr,
      const Aws::LaunchWizard::LaunchWizardClientConfiguration& clientConfiguration = Aws::LaunchWizard::LaunchWizardClientConfiguration());
 
  LaunchWizardClient(
      const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
      std::shared_ptr<LaunchWizardEndpointProviderBase> endpointProvider = nullptr,
      const Aws::LaunchWizard::LaunchWizardClientConfiguration& clientConfiguration = Aws::LaunchWizard::LaunchWizardClientConfiguration());
 
  /* Legacy constructors due deprecation */
  LaunchWizardClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  LaunchWizardClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  LaunchWizardClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                     const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~LaunchWizardClient();
 
  virtual Model::CreateDeploymentOutcome CreateDeployment(const Model::CreateDeploymentRequest& request) const;
 
  template <typename CreateDeploymentRequestT = Model::CreateDeploymentRequest>
  Model::CreateDeploymentOutcomeCallable CreateDeploymentCallable(const CreateDeploymentRequestT& request) const {
    return SubmitCallable(&LaunchWizardClient::CreateDeployment, request);
  }
 
  template <typename CreateDeploymentRequestT = Model::CreateDeploymentRequest>
  void CreateDeploymentAsync(const CreateDeploymentRequestT& request, const CreateDeploymentResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LaunchWizardClient::CreateDeployment, request, handler, context);
  }
 
  virtual Model::DeleteDeploymentOutcome DeleteDeployment(const Model::DeleteDeploymentRequest& request) const;
 
  template <typename DeleteDeploymentRequestT = Model::DeleteDeploymentRequest>
  Model::DeleteDeploymentOutcomeCallable DeleteDeploymentCallable(const DeleteDeploymentRequestT& request) const {
    return SubmitCallable(&LaunchWizardClient::DeleteDeployment, request);
  }
 
  template <typename DeleteDeploymentRequestT = Model::DeleteDeploymentRequest>
  void DeleteDeploymentAsync(const DeleteDeploymentRequestT& request, const DeleteDeploymentResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LaunchWizardClient::DeleteDeployment, request, handler, context);
  }
 
  virtual Model::GetDeploymentOutcome GetDeployment(const Model::GetDeploymentRequest& request) const;
 
  template <typename GetDeploymentRequestT = Model::GetDeploymentRequest>
  Model::GetDeploymentOutcomeCallable GetDeploymentCallable(const GetDeploymentRequestT& request) const {
    return SubmitCallable(&LaunchWizardClient::GetDeployment, request);
  }
 
  template <typename GetDeploymentRequestT = Model::GetDeploymentRequest>
  void GetDeploymentAsync(const GetDeploymentRequestT& request, const GetDeploymentResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LaunchWizardClient::GetDeployment, request, handler, context);
  }
 
  virtual Model::GetDeploymentPatternVersionOutcome GetDeploymentPatternVersion(
      const Model::GetDeploymentPatternVersionRequest& request) const;
 
  template <typename GetDeploymentPatternVersionRequestT = Model::GetDeploymentPatternVersionRequest>
  Model::GetDeploymentPatternVersionOutcomeCallable GetDeploymentPatternVersionCallable(
      const GetDeploymentPatternVersionRequestT& request) const {
    return SubmitCallable(&LaunchWizardClient::GetDeploymentPatternVersion, request);
  }
 
  template <typename GetDeploymentPatternVersionRequestT = Model::GetDeploymentPatternVersionRequest>
  void GetDeploymentPatternVersionAsync(const GetDeploymentPatternVersionRequestT& request,
                                        const GetDeploymentPatternVersionResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LaunchWizardClient::GetDeploymentPatternVersion, request, handler, context);
  }
 
  virtual Model::GetWorkloadOutcome GetWorkload(const Model::GetWorkloadRequest& request) const;
 
  template <typename GetWorkloadRequestT = Model::GetWorkloadRequest>
  Model::GetWorkloadOutcomeCallable GetWorkloadCallable(const GetWorkloadRequestT& request) const {
    return SubmitCallable(&LaunchWizardClient::GetWorkload, request);
  }
 
  template <typename GetWorkloadRequestT = Model::GetWorkloadRequest>
  void GetWorkloadAsync(const GetWorkloadRequestT& request, const GetWorkloadResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LaunchWizardClient::GetWorkload, request, handler, context);
  }
 
  virtual Model::GetWorkloadDeploymentPatternOutcome GetWorkloadDeploymentPattern(
      const Model::GetWorkloadDeploymentPatternRequest& request) const;
 
  template <typename GetWorkloadDeploymentPatternRequestT = Model::GetWorkloadDeploymentPatternRequest>
  Model::GetWorkloadDeploymentPatternOutcomeCallable GetWorkloadDeploymentPatternCallable(
      const GetWorkloadDeploymentPatternRequestT& request) const {
    return SubmitCallable(&LaunchWizardClient::GetWorkloadDeploymentPattern, request);
  }
 
  template <typename GetWorkloadDeploymentPatternRequestT = Model::GetWorkloadDeploymentPatternRequest>
  void GetWorkloadDeploymentPatternAsync(const GetWorkloadDeploymentPatternRequestT& request,
                                         const GetWorkloadDeploymentPatternResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LaunchWizardClient::GetWorkloadDeploymentPattern, request, handler, context);
  }
 
  virtual Model::ListDeploymentEventsOutcome ListDeploymentEvents(const Model::ListDeploymentEventsRequest& request) const;
 
  template <typename ListDeploymentEventsRequestT = Model::ListDeploymentEventsRequest>
  Model::ListDeploymentEventsOutcomeCallable ListDeploymentEventsCallable(const ListDeploymentEventsRequestT& request) const {
    return SubmitCallable(&LaunchWizardClient::ListDeploymentEvents, request);
  }
 
  template <typename ListDeploymentEventsRequestT = Model::ListDeploymentEventsRequest>
  void ListDeploymentEventsAsync(const ListDeploymentEventsRequestT& request, const ListDeploymentEventsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LaunchWizardClient::ListDeploymentEvents, request, handler, context);
  }
 
  virtual Model::ListDeploymentPatternVersionsOutcome ListDeploymentPatternVersions(
      const Model::ListDeploymentPatternVersionsRequest& request) const;
 
  template <typename ListDeploymentPatternVersionsRequestT = Model::ListDeploymentPatternVersionsRequest>
  Model::ListDeploymentPatternVersionsOutcomeCallable ListDeploymentPatternVersionsCallable(
      const ListDeploymentPatternVersionsRequestT& request) const {
    return SubmitCallable(&LaunchWizardClient::ListDeploymentPatternVersions, request);
  }
 
  template <typename ListDeploymentPatternVersionsRequestT = Model::ListDeploymentPatternVersionsRequest>
  void ListDeploymentPatternVersionsAsync(const ListDeploymentPatternVersionsRequestT& request,
                                          const ListDeploymentPatternVersionsResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LaunchWizardClient::ListDeploymentPatternVersions, request, handler, context);
  }
 
  virtual Model::ListDeploymentsOutcome ListDeployments(const Model::ListDeploymentsRequest& request = {}) const;
 
  template <typename ListDeploymentsRequestT = Model::ListDeploymentsRequest>
  Model::ListDeploymentsOutcomeCallable ListDeploymentsCallable(const ListDeploymentsRequestT& request = {}) const {
    return SubmitCallable(&LaunchWizardClient::ListDeployments, request);
  }
 
  template <typename ListDeploymentsRequestT = Model::ListDeploymentsRequest>
  void ListDeploymentsAsync(const ListDeploymentsResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                            const ListDeploymentsRequestT& request = {}) const {
    return SubmitAsync(&LaunchWizardClient::ListDeployments, 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(&LaunchWizardClient::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(&LaunchWizardClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::ListWorkloadDeploymentPatternsOutcome ListWorkloadDeploymentPatterns(
      const Model::ListWorkloadDeploymentPatternsRequest& request) const;
 
  template <typename ListWorkloadDeploymentPatternsRequestT = Model::ListWorkloadDeploymentPatternsRequest>
  Model::ListWorkloadDeploymentPatternsOutcomeCallable ListWorkloadDeploymentPatternsCallable(
      const ListWorkloadDeploymentPatternsRequestT& request) const {
    return SubmitCallable(&LaunchWizardClient::ListWorkloadDeploymentPatterns, request);
  }
 
  template <typename ListWorkloadDeploymentPatternsRequestT = Model::ListWorkloadDeploymentPatternsRequest>
  void ListWorkloadDeploymentPatternsAsync(const ListWorkloadDeploymentPatternsRequestT& request,
                                           const ListWorkloadDeploymentPatternsResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LaunchWizardClient::ListWorkloadDeploymentPatterns, request, handler, context);
  }
 
  virtual Model::ListWorkloadsOutcome ListWorkloads(const Model::ListWorkloadsRequest& request = {}) const;
 
  template <typename ListWorkloadsRequestT = Model::ListWorkloadsRequest>
  Model::ListWorkloadsOutcomeCallable ListWorkloadsCallable(const ListWorkloadsRequestT& request = {}) const {
    return SubmitCallable(&LaunchWizardClient::ListWorkloads, request);
  }
 
  template <typename ListWorkloadsRequestT = Model::ListWorkloadsRequest>
  void ListWorkloadsAsync(const ListWorkloadsResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                          const ListWorkloadsRequestT& request = {}) const {
    return SubmitAsync(&LaunchWizardClient::ListWorkloads, 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(&LaunchWizardClient::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(&LaunchWizardClient::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(&LaunchWizardClient::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(&LaunchWizardClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateDeploymentOutcome UpdateDeployment(const Model::UpdateDeploymentRequest& request) const;
 
  template <typename UpdateDeploymentRequestT = Model::UpdateDeploymentRequest>
  Model::UpdateDeploymentOutcomeCallable UpdateDeploymentCallable(const UpdateDeploymentRequestT& request) const {
    return SubmitCallable(&LaunchWizardClient::UpdateDeployment, request);
  }
 
  template <typename UpdateDeploymentRequestT = Model::UpdateDeploymentRequest>
  void UpdateDeploymentAsync(const UpdateDeploymentRequestT& request, const UpdateDeploymentResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LaunchWizardClient::UpdateDeployment, request, handler, context);
  }
 
  void OverrideEndpoint(const Aws::String& endpoint);
  std::shared_ptr<LaunchWizardEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<LaunchWizardClient>;
  void init(const LaunchWizardClientConfiguration& clientConfiguration);
 
  LaunchWizardClientConfiguration m_clientConfiguration;
  std::shared_ptr<LaunchWizardEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace LaunchWizard
}  // namespace Aws