SecurityIRClient.h

 
#pragma once
#include <aws/security-ir/SecurityIR_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/security-ir/SecurityIRServiceClientModel.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::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::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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      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