SupportClient.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/support/SupportPaginationBase.h>
#include <aws/support/SupportServiceClientModel.h>
#include <aws/support/SupportWaiter.h>
#include <aws/support/Support_EXPORTS.h>
 
namespace Aws {
namespace Support {
class AWS_SUPPORT_API SupportClient : public Aws::Client::AWSJsonClient,
                                      public Aws::Client::ClientWithAsyncTemplateMethods<SupportClient>,
                                      public SupportPaginationBase<SupportClient>,
                                      public SupportWaiter<SupportClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef SupportClientConfiguration ClientConfigurationType;
  typedef SupportEndpointProvider EndpointProviderType;
 
  SupportClient(const Aws::Support::SupportClientConfiguration& clientConfiguration = Aws::Support::SupportClientConfiguration(),
                std::shared_ptr<SupportEndpointProviderBase> endpointProvider = nullptr);
 
  SupportClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<SupportEndpointProviderBase> endpointProvider = nullptr,
                const Aws::Support::SupportClientConfiguration& clientConfiguration = Aws::Support::SupportClientConfiguration());
 
  SupportClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                std::shared_ptr<SupportEndpointProviderBase> endpointProvider = nullptr,
                const Aws::Support::SupportClientConfiguration& clientConfiguration = Aws::Support::SupportClientConfiguration());
 
  /* Legacy constructors due deprecation */
  SupportClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  SupportClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  SupportClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~SupportClient();
 
  virtual Model::AddAttachmentsToSetOutcome AddAttachmentsToSet(const Model::AddAttachmentsToSetRequest& request) const;
 
  template <typename AddAttachmentsToSetRequestT = Model::AddAttachmentsToSetRequest>
  Model::AddAttachmentsToSetOutcomeCallable AddAttachmentsToSetCallable(const AddAttachmentsToSetRequestT& request) const {
    return SubmitCallable(&SupportClient::AddAttachmentsToSet, request);
  }
 
  template <typename AddAttachmentsToSetRequestT = Model::AddAttachmentsToSetRequest>
  void AddAttachmentsToSetAsync(const AddAttachmentsToSetRequestT& request, const AddAttachmentsToSetResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SupportClient::AddAttachmentsToSet, request, handler, context);
  }
 
  virtual Model::AddCommunicationToCaseOutcome AddCommunicationToCase(const Model::AddCommunicationToCaseRequest& request) const;
 
  template <typename AddCommunicationToCaseRequestT = Model::AddCommunicationToCaseRequest>
  Model::AddCommunicationToCaseOutcomeCallable AddCommunicationToCaseCallable(const AddCommunicationToCaseRequestT& request) const {
    return SubmitCallable(&SupportClient::AddCommunicationToCase, request);
  }
 
  template <typename AddCommunicationToCaseRequestT = Model::AddCommunicationToCaseRequest>
  void AddCommunicationToCaseAsync(const AddCommunicationToCaseRequestT& request,
                                   const AddCommunicationToCaseResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SupportClient::AddCommunicationToCase, request, handler, context);
  }
 
  virtual Model::CompleteAttachmentUploadOutcome CompleteAttachmentUpload(const Model::CompleteAttachmentUploadRequest& request) const;
 
  template <typename CompleteAttachmentUploadRequestT = Model::CompleteAttachmentUploadRequest>
  Model::CompleteAttachmentUploadOutcomeCallable CompleteAttachmentUploadCallable(const CompleteAttachmentUploadRequestT& request) const {
    return SubmitCallable(&SupportClient::CompleteAttachmentUpload, request);
  }
 
  template <typename CompleteAttachmentUploadRequestT = Model::CompleteAttachmentUploadRequest>
  void CompleteAttachmentUploadAsync(const CompleteAttachmentUploadRequestT& request,
                                     const CompleteAttachmentUploadResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SupportClient::CompleteAttachmentUpload, request, handler, context);
  }
 
  virtual Model::CreateCaseOutcome CreateCase(const Model::CreateCaseRequest& request) const;
 
  template <typename CreateCaseRequestT = Model::CreateCaseRequest>
  Model::CreateCaseOutcomeCallable CreateCaseCallable(const CreateCaseRequestT& request) const {
    return SubmitCallable(&SupportClient::CreateCase, request);
  }
 
  template <typename CreateCaseRequestT = Model::CreateCaseRequest>
  void CreateCaseAsync(const CreateCaseRequestT& request, const CreateCaseResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SupportClient::CreateCase, request, handler, context);
  }
 
  virtual Model::DescribeAttachmentOutcome DescribeAttachment(const Model::DescribeAttachmentRequest& request) const;
 
  template <typename DescribeAttachmentRequestT = Model::DescribeAttachmentRequest>
  Model::DescribeAttachmentOutcomeCallable DescribeAttachmentCallable(const DescribeAttachmentRequestT& request) const {
    return SubmitCallable(&SupportClient::DescribeAttachment, request);
  }
 
  template <typename DescribeAttachmentRequestT = Model::DescribeAttachmentRequest>
  void DescribeAttachmentAsync(const DescribeAttachmentRequestT& request, const DescribeAttachmentResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SupportClient::DescribeAttachment, request, handler, context);
  }
 
  virtual Model::DescribeAttachmentUploadStatusOutcome DescribeAttachmentUploadStatus(
      const Model::DescribeAttachmentUploadStatusRequest& request) const;
 
  template <typename DescribeAttachmentUploadStatusRequestT = Model::DescribeAttachmentUploadStatusRequest>
  Model::DescribeAttachmentUploadStatusOutcomeCallable DescribeAttachmentUploadStatusCallable(
      const DescribeAttachmentUploadStatusRequestT& request) const {
    return SubmitCallable(&SupportClient::DescribeAttachmentUploadStatus, request);
  }
 
  template <typename DescribeAttachmentUploadStatusRequestT = Model::DescribeAttachmentUploadStatusRequest>
  void DescribeAttachmentUploadStatusAsync(const DescribeAttachmentUploadStatusRequestT& request,
                                           const DescribeAttachmentUploadStatusResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SupportClient::DescribeAttachmentUploadStatus, request, handler, context);
  }
 
  virtual Model::DescribeCasesOutcome DescribeCases(const Model::DescribeCasesRequest& request = {}) const;
 
  template <typename DescribeCasesRequestT = Model::DescribeCasesRequest>
  Model::DescribeCasesOutcomeCallable DescribeCasesCallable(const DescribeCasesRequestT& request = {}) const {
    return SubmitCallable(&SupportClient::DescribeCases, request);
  }
 
  template <typename DescribeCasesRequestT = Model::DescribeCasesRequest>
  void DescribeCasesAsync(const DescribeCasesResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                          const DescribeCasesRequestT& request = {}) const {
    return SubmitAsync(&SupportClient::DescribeCases, request, handler, context);
  }
 
  virtual Model::DescribeCommunicationsOutcome DescribeCommunications(const Model::DescribeCommunicationsRequest& request) const;
 
  template <typename DescribeCommunicationsRequestT = Model::DescribeCommunicationsRequest>
  Model::DescribeCommunicationsOutcomeCallable DescribeCommunicationsCallable(const DescribeCommunicationsRequestT& request) const {
    return SubmitCallable(&SupportClient::DescribeCommunications, request);
  }
 
  template <typename DescribeCommunicationsRequestT = Model::DescribeCommunicationsRequest>
  void DescribeCommunicationsAsync(const DescribeCommunicationsRequestT& request,
                                   const DescribeCommunicationsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SupportClient::DescribeCommunications, request, handler, context);
  }
 
  virtual Model::DescribeCreateCaseOptionsOutcome DescribeCreateCaseOptions(const Model::DescribeCreateCaseOptionsRequest& request) const;
 
  template <typename DescribeCreateCaseOptionsRequestT = Model::DescribeCreateCaseOptionsRequest>
  Model::DescribeCreateCaseOptionsOutcomeCallable DescribeCreateCaseOptionsCallable(
      const DescribeCreateCaseOptionsRequestT& request) const {
    return SubmitCallable(&SupportClient::DescribeCreateCaseOptions, request);
  }
 
  template <typename DescribeCreateCaseOptionsRequestT = Model::DescribeCreateCaseOptionsRequest>
  void DescribeCreateCaseOptionsAsync(const DescribeCreateCaseOptionsRequestT& request,
                                      const DescribeCreateCaseOptionsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SupportClient::DescribeCreateCaseOptions, request, handler, context);
  }
 
  virtual Model::DescribeServicesOutcome DescribeServices(const Model::DescribeServicesRequest& request = {}) const;
 
  template <typename DescribeServicesRequestT = Model::DescribeServicesRequest>
  Model::DescribeServicesOutcomeCallable DescribeServicesCallable(const DescribeServicesRequestT& request = {}) const {
    return SubmitCallable(&SupportClient::DescribeServices, request);
  }
 
  template <typename DescribeServicesRequestT = Model::DescribeServicesRequest>
  void DescribeServicesAsync(const DescribeServicesResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const DescribeServicesRequestT& request = {}) const {
    return SubmitAsync(&SupportClient::DescribeServices, request, handler, context);
  }
 
  virtual Model::DescribeSeverityLevelsOutcome DescribeSeverityLevels(const Model::DescribeSeverityLevelsRequest& request = {}) const;
 
  template <typename DescribeSeverityLevelsRequestT = Model::DescribeSeverityLevelsRequest>
  Model::DescribeSeverityLevelsOutcomeCallable DescribeSeverityLevelsCallable(const DescribeSeverityLevelsRequestT& request = {}) const {
    return SubmitCallable(&SupportClient::DescribeSeverityLevels, request);
  }
 
  template <typename DescribeSeverityLevelsRequestT = Model::DescribeSeverityLevelsRequest>
  void DescribeSeverityLevelsAsync(const DescribeSeverityLevelsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                   const DescribeSeverityLevelsRequestT& request = {}) const {
    return SubmitAsync(&SupportClient::DescribeSeverityLevels, request, handler, context);
  }
 
  virtual Model::DescribeSupportedLanguagesOutcome DescribeSupportedLanguages(
      const Model::DescribeSupportedLanguagesRequest& request) const;
 
  template <typename DescribeSupportedLanguagesRequestT = Model::DescribeSupportedLanguagesRequest>
  Model::DescribeSupportedLanguagesOutcomeCallable DescribeSupportedLanguagesCallable(
      const DescribeSupportedLanguagesRequestT& request) const {
    return SubmitCallable(&SupportClient::DescribeSupportedLanguages, request);
  }
 
  template <typename DescribeSupportedLanguagesRequestT = Model::DescribeSupportedLanguagesRequest>
  void DescribeSupportedLanguagesAsync(const DescribeSupportedLanguagesRequestT& request,
                                       const DescribeSupportedLanguagesResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SupportClient::DescribeSupportedLanguages, request, handler, context);
  }
 
  virtual Model::DescribeTrustedAdvisorCheckRefreshStatusesOutcome DescribeTrustedAdvisorCheckRefreshStatuses(
      const Model::DescribeTrustedAdvisorCheckRefreshStatusesRequest& request) const;
 
  template <typename DescribeTrustedAdvisorCheckRefreshStatusesRequestT = Model::DescribeTrustedAdvisorCheckRefreshStatusesRequest>
  Model::DescribeTrustedAdvisorCheckRefreshStatusesOutcomeCallable DescribeTrustedAdvisorCheckRefreshStatusesCallable(
      const DescribeTrustedAdvisorCheckRefreshStatusesRequestT& request) const {
    return SubmitCallable(&SupportClient::DescribeTrustedAdvisorCheckRefreshStatuses, request);
  }
 
  template <typename DescribeTrustedAdvisorCheckRefreshStatusesRequestT = Model::DescribeTrustedAdvisorCheckRefreshStatusesRequest>
  void DescribeTrustedAdvisorCheckRefreshStatusesAsync(
      const DescribeTrustedAdvisorCheckRefreshStatusesRequestT& request,
      const DescribeTrustedAdvisorCheckRefreshStatusesResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SupportClient::DescribeTrustedAdvisorCheckRefreshStatuses, request, handler, context);
  }
 
  virtual Model::DescribeTrustedAdvisorCheckResultOutcome DescribeTrustedAdvisorCheckResult(
      const Model::DescribeTrustedAdvisorCheckResultRequest& request) const;
 
  template <typename DescribeTrustedAdvisorCheckResultRequestT = Model::DescribeTrustedAdvisorCheckResultRequest>
  Model::DescribeTrustedAdvisorCheckResultOutcomeCallable DescribeTrustedAdvisorCheckResultCallable(
      const DescribeTrustedAdvisorCheckResultRequestT& request) const {
    return SubmitCallable(&SupportClient::DescribeTrustedAdvisorCheckResult, request);
  }
 
  template <typename DescribeTrustedAdvisorCheckResultRequestT = Model::DescribeTrustedAdvisorCheckResultRequest>
  void DescribeTrustedAdvisorCheckResultAsync(const DescribeTrustedAdvisorCheckResultRequestT& request,
                                              const DescribeTrustedAdvisorCheckResultResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SupportClient::DescribeTrustedAdvisorCheckResult, request, handler, context);
  }
 
  virtual Model::DescribeTrustedAdvisorCheckSummariesOutcome DescribeTrustedAdvisorCheckSummaries(
      const Model::DescribeTrustedAdvisorCheckSummariesRequest& request) const;
 
  template <typename DescribeTrustedAdvisorCheckSummariesRequestT = Model::DescribeTrustedAdvisorCheckSummariesRequest>
  Model::DescribeTrustedAdvisorCheckSummariesOutcomeCallable DescribeTrustedAdvisorCheckSummariesCallable(
      const DescribeTrustedAdvisorCheckSummariesRequestT& request) const {
    return SubmitCallable(&SupportClient::DescribeTrustedAdvisorCheckSummaries, request);
  }
 
  template <typename DescribeTrustedAdvisorCheckSummariesRequestT = Model::DescribeTrustedAdvisorCheckSummariesRequest>
  void DescribeTrustedAdvisorCheckSummariesAsync(const DescribeTrustedAdvisorCheckSummariesRequestT& request,
                                                 const DescribeTrustedAdvisorCheckSummariesResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SupportClient::DescribeTrustedAdvisorCheckSummaries, request, handler, context);
  }
 
  virtual Model::DescribeTrustedAdvisorChecksOutcome DescribeTrustedAdvisorChecks(
      const Model::DescribeTrustedAdvisorChecksRequest& request) const;
 
  template <typename DescribeTrustedAdvisorChecksRequestT = Model::DescribeTrustedAdvisorChecksRequest>
  Model::DescribeTrustedAdvisorChecksOutcomeCallable DescribeTrustedAdvisorChecksCallable(
      const DescribeTrustedAdvisorChecksRequestT& request) const {
    return SubmitCallable(&SupportClient::DescribeTrustedAdvisorChecks, request);
  }
 
  template <typename DescribeTrustedAdvisorChecksRequestT = Model::DescribeTrustedAdvisorChecksRequest>
  void DescribeTrustedAdvisorChecksAsync(const DescribeTrustedAdvisorChecksRequestT& request,
                                         const DescribeTrustedAdvisorChecksResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SupportClient::DescribeTrustedAdvisorChecks, request, handler, context);
  }
 
  virtual Model::GetAttachmentDownloadLinkOutcome GetAttachmentDownloadLink(const Model::GetAttachmentDownloadLinkRequest& request) const;
 
  template <typename GetAttachmentDownloadLinkRequestT = Model::GetAttachmentDownloadLinkRequest>
  Model::GetAttachmentDownloadLinkOutcomeCallable GetAttachmentDownloadLinkCallable(
      const GetAttachmentDownloadLinkRequestT& request) const {
    return SubmitCallable(&SupportClient::GetAttachmentDownloadLink, request);
  }
 
  template <typename GetAttachmentDownloadLinkRequestT = Model::GetAttachmentDownloadLinkRequest>
  void GetAttachmentDownloadLinkAsync(const GetAttachmentDownloadLinkRequestT& request,
                                      const GetAttachmentDownloadLinkResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SupportClient::GetAttachmentDownloadLink, request, handler, context);
  }
 
  virtual Model::GetAttachmentUploadLinksOutcome GetAttachmentUploadLinks(const Model::GetAttachmentUploadLinksRequest& request) const;
 
  template <typename GetAttachmentUploadLinksRequestT = Model::GetAttachmentUploadLinksRequest>
  Model::GetAttachmentUploadLinksOutcomeCallable GetAttachmentUploadLinksCallable(const GetAttachmentUploadLinksRequestT& request) const {
    return SubmitCallable(&SupportClient::GetAttachmentUploadLinks, request);
  }
 
  template <typename GetAttachmentUploadLinksRequestT = Model::GetAttachmentUploadLinksRequest>
  void GetAttachmentUploadLinksAsync(const GetAttachmentUploadLinksRequestT& request,
                                     const GetAttachmentUploadLinksResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SupportClient::GetAttachmentUploadLinks, request, handler, context);
  }
 
  virtual Model::RefreshTrustedAdvisorCheckOutcome RefreshTrustedAdvisorCheck(
      const Model::RefreshTrustedAdvisorCheckRequest& request) const;
 
  template <typename RefreshTrustedAdvisorCheckRequestT = Model::RefreshTrustedAdvisorCheckRequest>
  Model::RefreshTrustedAdvisorCheckOutcomeCallable RefreshTrustedAdvisorCheckCallable(
      const RefreshTrustedAdvisorCheckRequestT& request) const {
    return SubmitCallable(&SupportClient::RefreshTrustedAdvisorCheck, request);
  }
 
  template <typename RefreshTrustedAdvisorCheckRequestT = Model::RefreshTrustedAdvisorCheckRequest>
  void RefreshTrustedAdvisorCheckAsync(const RefreshTrustedAdvisorCheckRequestT& request,
                                       const RefreshTrustedAdvisorCheckResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SupportClient::RefreshTrustedAdvisorCheck, request, handler, context);
  }
 
  virtual Model::ResolveCaseOutcome ResolveCase(const Model::ResolveCaseRequest& request = {}) const;
 
  template <typename ResolveCaseRequestT = Model::ResolveCaseRequest>
  Model::ResolveCaseOutcomeCallable ResolveCaseCallable(const ResolveCaseRequestT& request = {}) const {
    return SubmitCallable(&SupportClient::ResolveCase, request);
  }
 
  template <typename ResolveCaseRequestT = Model::ResolveCaseRequest>
  void ResolveCaseAsync(const ResolveCaseResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                        const ResolveCaseRequestT& request = {}) const {
    return SubmitAsync(&SupportClient::ResolveCase, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<SupportEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<SupportClient>;
  void init(const SupportClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, SupportError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  SupportClientConfiguration m_clientConfiguration;
  std::shared_ptr<SupportEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace Support
}  // namespace Aws