SecurityIRClient.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/security-ir/SecurityIRServiceClientModel.h>
#include <aws/security-ir/SecurityIR_EXPORTS.h>
 
namespace Aws {
namespace SecurityIR {
class AWS_SECURITYIR_API SecurityIRClient : public Aws::Client::AWSJsonClient,
                                            public Aws::Client::ClientWithAsyncTemplateMethods<SecurityIRClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef SecurityIRClientConfiguration ClientConfigurationType;
  typedef SecurityIREndpointProvider EndpointProviderType;
 
  SecurityIRClient(
      const Aws::SecurityIR::SecurityIRClientConfiguration& clientConfiguration = Aws::SecurityIR::SecurityIRClientConfiguration(),
      std::shared_ptr<SecurityIREndpointProviderBase> endpointProvider = nullptr);
 
  SecurityIRClient(
      const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<SecurityIREndpointProviderBase> endpointProvider = nullptr,
      const Aws::SecurityIR::SecurityIRClientConfiguration& clientConfiguration = Aws::SecurityIR::SecurityIRClientConfiguration());
 
  SecurityIRClient(
      const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
      std::shared_ptr<SecurityIREndpointProviderBase> endpointProvider = nullptr,
      const Aws::SecurityIR::SecurityIRClientConfiguration& clientConfiguration = Aws::SecurityIR::SecurityIRClientConfiguration());
 
  /* Legacy constructors due deprecation */
  SecurityIRClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  SecurityIRClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  SecurityIRClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                   const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~SecurityIRClient();
 
  virtual Model::BatchGetMemberAccountDetailsOutcome BatchGetMemberAccountDetails(
      const Model::BatchGetMemberAccountDetailsRequest& request) const;
 
  template <typename BatchGetMemberAccountDetailsRequestT = Model::BatchGetMemberAccountDetailsRequest>
  Model::BatchGetMemberAccountDetailsOutcomeCallable BatchGetMemberAccountDetailsCallable(
      const BatchGetMemberAccountDetailsRequestT& request) const {
    return SubmitCallable(&SecurityIRClient::BatchGetMemberAccountDetails, request);
  }
 
  template <typename BatchGetMemberAccountDetailsRequestT = Model::BatchGetMemberAccountDetailsRequest>
  void BatchGetMemberAccountDetailsAsync(const BatchGetMemberAccountDetailsRequestT& request,
                                         const BatchGetMemberAccountDetailsResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityIRClient::BatchGetMemberAccountDetails, request, handler, context);
  }
 
  virtual Model::CancelMembershipOutcome CancelMembership(const Model::CancelMembershipRequest& request) const;
 
  template <typename CancelMembershipRequestT = Model::CancelMembershipRequest>
  Model::CancelMembershipOutcomeCallable CancelMembershipCallable(const CancelMembershipRequestT& request) const {
    return SubmitCallable(&SecurityIRClient::CancelMembership, request);
  }
 
  template <typename CancelMembershipRequestT = Model::CancelMembershipRequest>
  void CancelMembershipAsync(const CancelMembershipRequestT& request, const CancelMembershipResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityIRClient::CancelMembership, request, handler, context);
  }
 
  virtual Model::CloseCaseOutcome CloseCase(const Model::CloseCaseRequest& request) const;
 
  template <typename CloseCaseRequestT = Model::CloseCaseRequest>
  Model::CloseCaseOutcomeCallable CloseCaseCallable(const CloseCaseRequestT& request) const {
    return SubmitCallable(&SecurityIRClient::CloseCase, request);
  }
 
  template <typename CloseCaseRequestT = Model::CloseCaseRequest>
  void CloseCaseAsync(const CloseCaseRequestT& request, const CloseCaseResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityIRClient::CloseCase, 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(&SecurityIRClient::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(&SecurityIRClient::CreateCase, request, handler, context);
  }
 
  virtual Model::CreateCaseCommentOutcome CreateCaseComment(const Model::CreateCaseCommentRequest& request) const;
 
  template <typename CreateCaseCommentRequestT = Model::CreateCaseCommentRequest>
  Model::CreateCaseCommentOutcomeCallable CreateCaseCommentCallable(const CreateCaseCommentRequestT& request) const {
    return SubmitCallable(&SecurityIRClient::CreateCaseComment, request);
  }
 
  template <typename CreateCaseCommentRequestT = Model::CreateCaseCommentRequest>
  void CreateCaseCommentAsync(const CreateCaseCommentRequestT& request, const CreateCaseCommentResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityIRClient::CreateCaseComment, request, handler, context);
  }
 
  virtual Model::CreateMembershipOutcome CreateMembership(const Model::CreateMembershipRequest& request) const;
 
  template <typename CreateMembershipRequestT = Model::CreateMembershipRequest>
  Model::CreateMembershipOutcomeCallable CreateMembershipCallable(const CreateMembershipRequestT& request) const {
    return SubmitCallable(&SecurityIRClient::CreateMembership, request);
  }
 
  template <typename CreateMembershipRequestT = Model::CreateMembershipRequest>
  void CreateMembershipAsync(const CreateMembershipRequestT& request, const CreateMembershipResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityIRClient::CreateMembership, request, handler, context);
  }
 
  virtual Model::GetCaseOutcome GetCase(const Model::GetCaseRequest& request) const;
 
  template <typename GetCaseRequestT = Model::GetCaseRequest>
  Model::GetCaseOutcomeCallable GetCaseCallable(const GetCaseRequestT& request) const {
    return SubmitCallable(&SecurityIRClient::GetCase, request);
  }
 
  template <typename GetCaseRequestT = Model::GetCaseRequest>
  void GetCaseAsync(const GetCaseRequestT& request, const GetCaseResponseReceivedHandler& handler,
                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityIRClient::GetCase, request, handler, context);
  }
 
  virtual Model::GetCaseAttachmentDownloadUrlOutcome GetCaseAttachmentDownloadUrl(
      const Model::GetCaseAttachmentDownloadUrlRequest& request) const;
 
  template <typename GetCaseAttachmentDownloadUrlRequestT = Model::GetCaseAttachmentDownloadUrlRequest>
  Model::GetCaseAttachmentDownloadUrlOutcomeCallable GetCaseAttachmentDownloadUrlCallable(
      const GetCaseAttachmentDownloadUrlRequestT& request) const {
    return SubmitCallable(&SecurityIRClient::GetCaseAttachmentDownloadUrl, request);
  }
 
  template <typename GetCaseAttachmentDownloadUrlRequestT = Model::GetCaseAttachmentDownloadUrlRequest>
  void GetCaseAttachmentDownloadUrlAsync(const GetCaseAttachmentDownloadUrlRequestT& request,
                                         const GetCaseAttachmentDownloadUrlResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityIRClient::GetCaseAttachmentDownloadUrl, request, handler, context);
  }
 
  virtual Model::GetCaseAttachmentUploadUrlOutcome GetCaseAttachmentUploadUrl(
      const Model::GetCaseAttachmentUploadUrlRequest& request) const;
 
  template <typename GetCaseAttachmentUploadUrlRequestT = Model::GetCaseAttachmentUploadUrlRequest>
  Model::GetCaseAttachmentUploadUrlOutcomeCallable GetCaseAttachmentUploadUrlCallable(
      const GetCaseAttachmentUploadUrlRequestT& request) const {
    return SubmitCallable(&SecurityIRClient::GetCaseAttachmentUploadUrl, request);
  }
 
  template <typename GetCaseAttachmentUploadUrlRequestT = Model::GetCaseAttachmentUploadUrlRequest>
  void GetCaseAttachmentUploadUrlAsync(const GetCaseAttachmentUploadUrlRequestT& request,
                                       const GetCaseAttachmentUploadUrlResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityIRClient::GetCaseAttachmentUploadUrl, request, handler, context);
  }
 
  virtual Model::GetMembershipOutcome GetMembership(const Model::GetMembershipRequest& request) const;
 
  template <typename GetMembershipRequestT = Model::GetMembershipRequest>
  Model::GetMembershipOutcomeCallable GetMembershipCallable(const GetMembershipRequestT& request) const {
    return SubmitCallable(&SecurityIRClient::GetMembership, request);
  }
 
  template <typename GetMembershipRequestT = Model::GetMembershipRequest>
  void GetMembershipAsync(const GetMembershipRequestT& request, const GetMembershipResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityIRClient::GetMembership, request, handler, context);
  }
 
  virtual Model::ListCaseEditsOutcome ListCaseEdits(const Model::ListCaseEditsRequest& request) const;
 
  template <typename ListCaseEditsRequestT = Model::ListCaseEditsRequest>
  Model::ListCaseEditsOutcomeCallable ListCaseEditsCallable(const ListCaseEditsRequestT& request) const {
    return SubmitCallable(&SecurityIRClient::ListCaseEdits, request);
  }
 
  template <typename ListCaseEditsRequestT = Model::ListCaseEditsRequest>
  void ListCaseEditsAsync(const ListCaseEditsRequestT& request, const ListCaseEditsResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityIRClient::ListCaseEdits, request, handler, context);
  }
 
  virtual Model::ListCasesOutcome ListCases(const Model::ListCasesRequest& request = {}) const;
 
  template <typename ListCasesRequestT = Model::ListCasesRequest>
  Model::ListCasesOutcomeCallable ListCasesCallable(const ListCasesRequestT& request = {}) const {
    return SubmitCallable(&SecurityIRClient::ListCases, request);
  }
 
  template <typename ListCasesRequestT = Model::ListCasesRequest>
  void ListCasesAsync(const ListCasesResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                      const ListCasesRequestT& request = {}) const {
    return SubmitAsync(&SecurityIRClient::ListCases, request, handler, context);
  }
 
  virtual Model::ListCommentsOutcome ListComments(const Model::ListCommentsRequest& request) const;
 
  template <typename ListCommentsRequestT = Model::ListCommentsRequest>
  Model::ListCommentsOutcomeCallable ListCommentsCallable(const ListCommentsRequestT& request) const {
    return SubmitCallable(&SecurityIRClient::ListComments, request);
  }
 
  template <typename ListCommentsRequestT = Model::ListCommentsRequest>
  void ListCommentsAsync(const ListCommentsRequestT& request, const ListCommentsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityIRClient::ListComments, request, handler, context);
  }
 
  virtual Model::ListInvestigationsOutcome ListInvestigations(const Model::ListInvestigationsRequest& request) const;
 
  template <typename ListInvestigationsRequestT = Model::ListInvestigationsRequest>
  Model::ListInvestigationsOutcomeCallable ListInvestigationsCallable(const ListInvestigationsRequestT& request) const {
    return SubmitCallable(&SecurityIRClient::ListInvestigations, request);
  }
 
  template <typename ListInvestigationsRequestT = Model::ListInvestigationsRequest>
  void ListInvestigationsAsync(const ListInvestigationsRequestT& request, const ListInvestigationsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityIRClient::ListInvestigations, request, handler, context);
  }
 
  virtual Model::ListMembershipsOutcome ListMemberships(const Model::ListMembershipsRequest& request = {}) const;
 
  template <typename ListMembershipsRequestT = Model::ListMembershipsRequest>
  Model::ListMembershipsOutcomeCallable ListMembershipsCallable(const ListMembershipsRequestT& request = {}) const {
    return SubmitCallable(&SecurityIRClient::ListMemberships, request);
  }
 
  template <typename ListMembershipsRequestT = Model::ListMembershipsRequest>
  void ListMembershipsAsync(const ListMembershipsResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                            const ListMembershipsRequestT& request = {}) const {
    return SubmitAsync(&SecurityIRClient::ListMemberships, 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(&SecurityIRClient::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(&SecurityIRClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::SendFeedbackOutcome SendFeedback(const Model::SendFeedbackRequest& request) const;
 
  template <typename SendFeedbackRequestT = Model::SendFeedbackRequest>
  Model::SendFeedbackOutcomeCallable SendFeedbackCallable(const SendFeedbackRequestT& request) const {
    return SubmitCallable(&SecurityIRClient::SendFeedback, request);
  }
 
  template <typename SendFeedbackRequestT = Model::SendFeedbackRequest>
  void SendFeedbackAsync(const SendFeedbackRequestT& request, const SendFeedbackResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityIRClient::SendFeedback, 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(&SecurityIRClient::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(&SecurityIRClient::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(&SecurityIRClient::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(&SecurityIRClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateCaseOutcome UpdateCase(const Model::UpdateCaseRequest& request) const;
 
  template <typename UpdateCaseRequestT = Model::UpdateCaseRequest>
  Model::UpdateCaseOutcomeCallable UpdateCaseCallable(const UpdateCaseRequestT& request) const {
    return SubmitCallable(&SecurityIRClient::UpdateCase, request);
  }
 
  template <typename UpdateCaseRequestT = Model::UpdateCaseRequest>
  void UpdateCaseAsync(const UpdateCaseRequestT& request, const UpdateCaseResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityIRClient::UpdateCase, request, handler, context);
  }
 
  virtual Model::UpdateCaseCommentOutcome UpdateCaseComment(const Model::UpdateCaseCommentRequest& request) const;
 
  template <typename UpdateCaseCommentRequestT = Model::UpdateCaseCommentRequest>
  Model::UpdateCaseCommentOutcomeCallable UpdateCaseCommentCallable(const UpdateCaseCommentRequestT& request) const {
    return SubmitCallable(&SecurityIRClient::UpdateCaseComment, request);
  }
 
  template <typename UpdateCaseCommentRequestT = Model::UpdateCaseCommentRequest>
  void UpdateCaseCommentAsync(const UpdateCaseCommentRequestT& request, const UpdateCaseCommentResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityIRClient::UpdateCaseComment, request, handler, context);
  }
 
  virtual Model::UpdateCaseStatusOutcome UpdateCaseStatus(const Model::UpdateCaseStatusRequest& request) const;
 
  template <typename UpdateCaseStatusRequestT = Model::UpdateCaseStatusRequest>
  Model::UpdateCaseStatusOutcomeCallable UpdateCaseStatusCallable(const UpdateCaseStatusRequestT& request) const {
    return SubmitCallable(&SecurityIRClient::UpdateCaseStatus, request);
  }
 
  template <typename UpdateCaseStatusRequestT = Model::UpdateCaseStatusRequest>
  void UpdateCaseStatusAsync(const UpdateCaseStatusRequestT& request, const UpdateCaseStatusResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityIRClient::UpdateCaseStatus, request, handler, context);
  }
 
  virtual Model::UpdateMembershipOutcome UpdateMembership(const Model::UpdateMembershipRequest& request) const;
 
  template <typename UpdateMembershipRequestT = Model::UpdateMembershipRequest>
  Model::UpdateMembershipOutcomeCallable UpdateMembershipCallable(const UpdateMembershipRequestT& request) const {
    return SubmitCallable(&SecurityIRClient::UpdateMembership, request);
  }
 
  template <typename UpdateMembershipRequestT = Model::UpdateMembershipRequest>
  void UpdateMembershipAsync(const UpdateMembershipRequestT& request, const UpdateMembershipResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityIRClient::UpdateMembership, request, handler, context);
  }
 
  virtual Model::UpdateResolverTypeOutcome UpdateResolverType(const Model::UpdateResolverTypeRequest& request) const;
 
  template <typename UpdateResolverTypeRequestT = Model::UpdateResolverTypeRequest>
  Model::UpdateResolverTypeOutcomeCallable UpdateResolverTypeCallable(const UpdateResolverTypeRequestT& request) const {
    return SubmitCallable(&SecurityIRClient::UpdateResolverType, request);
  }
 
  template <typename UpdateResolverTypeRequestT = Model::UpdateResolverTypeRequest>
  void UpdateResolverTypeAsync(const UpdateResolverTypeRequestT& request, const UpdateResolverTypeResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SecurityIRClient::UpdateResolverType, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<SecurityIREndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<SecurityIRClient>;
  void init(const SecurityIRClientConfiguration& clientConfiguration);
 
  SecurityIRClientConfiguration m_clientConfiguration;
  std::shared_ptr<SecurityIREndpointProviderBase> m_endpointProvider;
};
 
}  // namespace SecurityIR
}  // namespace Aws