SSMIncidentsClient.h

 
#pragma once
#include <aws/ssm-incidents/SSMIncidents_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/ssm-incidents/SSMIncidentsServiceClientModel.h>
 
namespace Aws
{
namespace SSMIncidents
{
  class AWS_SSMINCIDENTS_API SSMIncidentsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<SSMIncidentsClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef SSMIncidentsClientConfiguration ClientConfigurationType;
      typedef SSMIncidentsEndpointProvider EndpointProviderType;
 
        SSMIncidentsClient(const Aws::SSMIncidents::SSMIncidentsClientConfiguration& clientConfiguration = Aws::SSMIncidents::SSMIncidentsClientConfiguration(),
                           std::shared_ptr<SSMIncidentsEndpointProviderBase> endpointProvider = nullptr);
 
        SSMIncidentsClient(const Aws::Auth::AWSCredentials& credentials,
                           std::shared_ptr<SSMIncidentsEndpointProviderBase> endpointProvider = nullptr,
                           const Aws::SSMIncidents::SSMIncidentsClientConfiguration& clientConfiguration = Aws::SSMIncidents::SSMIncidentsClientConfiguration());
 
        SSMIncidentsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                           std::shared_ptr<SSMIncidentsEndpointProviderBase> endpointProvider = nullptr,
                           const Aws::SSMIncidents::SSMIncidentsClientConfiguration& clientConfiguration = Aws::SSMIncidents::SSMIncidentsClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        SSMIncidentsClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        SSMIncidentsClient(const Aws::Auth::AWSCredentials& credentials,
                           const Aws::Client::ClientConfiguration& clientConfiguration);
 
        SSMIncidentsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                           const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~SSMIncidentsClient();
 
        virtual Model::BatchGetIncidentFindingsOutcome BatchGetIncidentFindings(const Model::BatchGetIncidentFindingsRequest& request) const;
 
        template<typename BatchGetIncidentFindingsRequestT = Model::BatchGetIncidentFindingsRequest>
        Model::BatchGetIncidentFindingsOutcomeCallable BatchGetIncidentFindingsCallable(const BatchGetIncidentFindingsRequestT& request) const
        {
            return SubmitCallable(&SSMIncidentsClient::BatchGetIncidentFindings, request);
        }
 
        template<typename BatchGetIncidentFindingsRequestT = Model::BatchGetIncidentFindingsRequest>
        void BatchGetIncidentFindingsAsync(const BatchGetIncidentFindingsRequestT& request, const BatchGetIncidentFindingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMIncidentsClient::BatchGetIncidentFindings, request, handler, context);
        }
 
        virtual Model::CreateReplicationSetOutcome CreateReplicationSet(const Model::CreateReplicationSetRequest& request) const;
 
        template<typename CreateReplicationSetRequestT = Model::CreateReplicationSetRequest>
        Model::CreateReplicationSetOutcomeCallable CreateReplicationSetCallable(const CreateReplicationSetRequestT& request) const
        {
            return SubmitCallable(&SSMIncidentsClient::CreateReplicationSet, request);
        }
 
        template<typename CreateReplicationSetRequestT = Model::CreateReplicationSetRequest>
        void CreateReplicationSetAsync(const CreateReplicationSetRequestT& request, const CreateReplicationSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMIncidentsClient::CreateReplicationSet, request, handler, context);
        }
 
        virtual Model::CreateResponsePlanOutcome CreateResponsePlan(const Model::CreateResponsePlanRequest& request) const;
 
        template<typename CreateResponsePlanRequestT = Model::CreateResponsePlanRequest>
        Model::CreateResponsePlanOutcomeCallable CreateResponsePlanCallable(const CreateResponsePlanRequestT& request) const
        {
            return SubmitCallable(&SSMIncidentsClient::CreateResponsePlan, request);
        }
 
        template<typename CreateResponsePlanRequestT = Model::CreateResponsePlanRequest>
        void CreateResponsePlanAsync(const CreateResponsePlanRequestT& request, const CreateResponsePlanResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMIncidentsClient::CreateResponsePlan, request, handler, context);
        }
 
        virtual Model::CreateTimelineEventOutcome CreateTimelineEvent(const Model::CreateTimelineEventRequest& request) const;
 
        template<typename CreateTimelineEventRequestT = Model::CreateTimelineEventRequest>
        Model::CreateTimelineEventOutcomeCallable CreateTimelineEventCallable(const CreateTimelineEventRequestT& request) const
        {
            return SubmitCallable(&SSMIncidentsClient::CreateTimelineEvent, request);
        }
 
        template<typename CreateTimelineEventRequestT = Model::CreateTimelineEventRequest>
        void CreateTimelineEventAsync(const CreateTimelineEventRequestT& request, const CreateTimelineEventResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMIncidentsClient::CreateTimelineEvent, request, handler, context);
        }
 
        virtual Model::DeleteIncidentRecordOutcome DeleteIncidentRecord(const Model::DeleteIncidentRecordRequest& request) const;
 
        template<typename DeleteIncidentRecordRequestT = Model::DeleteIncidentRecordRequest>
        Model::DeleteIncidentRecordOutcomeCallable DeleteIncidentRecordCallable(const DeleteIncidentRecordRequestT& request) const
        {
            return SubmitCallable(&SSMIncidentsClient::DeleteIncidentRecord, request);
        }
 
        template<typename DeleteIncidentRecordRequestT = Model::DeleteIncidentRecordRequest>
        void DeleteIncidentRecordAsync(const DeleteIncidentRecordRequestT& request, const DeleteIncidentRecordResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMIncidentsClient::DeleteIncidentRecord, request, handler, context);
        }
 
        virtual Model::DeleteReplicationSetOutcome DeleteReplicationSet(const Model::DeleteReplicationSetRequest& request) const;
 
        template<typename DeleteReplicationSetRequestT = Model::DeleteReplicationSetRequest>
        Model::DeleteReplicationSetOutcomeCallable DeleteReplicationSetCallable(const DeleteReplicationSetRequestT& request) const
        {
            return SubmitCallable(&SSMIncidentsClient::DeleteReplicationSet, request);
        }
 
        template<typename DeleteReplicationSetRequestT = Model::DeleteReplicationSetRequest>
        void DeleteReplicationSetAsync(const DeleteReplicationSetRequestT& request, const DeleteReplicationSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMIncidentsClient::DeleteReplicationSet, request, handler, context);
        }
 
        virtual Model::DeleteResourcePolicyOutcome DeleteResourcePolicy(const Model::DeleteResourcePolicyRequest& request) const;
 
        template<typename DeleteResourcePolicyRequestT = Model::DeleteResourcePolicyRequest>
        Model::DeleteResourcePolicyOutcomeCallable DeleteResourcePolicyCallable(const DeleteResourcePolicyRequestT& request) const
        {
            return SubmitCallable(&SSMIncidentsClient::DeleteResourcePolicy, request);
        }
 
        template<typename DeleteResourcePolicyRequestT = Model::DeleteResourcePolicyRequest>
        void DeleteResourcePolicyAsync(const DeleteResourcePolicyRequestT& request, const DeleteResourcePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMIncidentsClient::DeleteResourcePolicy, request, handler, context);
        }
 
        virtual Model::DeleteResponsePlanOutcome DeleteResponsePlan(const Model::DeleteResponsePlanRequest& request) const;
 
        template<typename DeleteResponsePlanRequestT = Model::DeleteResponsePlanRequest>
        Model::DeleteResponsePlanOutcomeCallable DeleteResponsePlanCallable(const DeleteResponsePlanRequestT& request) const
        {
            return SubmitCallable(&SSMIncidentsClient::DeleteResponsePlan, request);
        }
 
        template<typename DeleteResponsePlanRequestT = Model::DeleteResponsePlanRequest>
        void DeleteResponsePlanAsync(const DeleteResponsePlanRequestT& request, const DeleteResponsePlanResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMIncidentsClient::DeleteResponsePlan, request, handler, context);
        }
 
        virtual Model::DeleteTimelineEventOutcome DeleteTimelineEvent(const Model::DeleteTimelineEventRequest& request) const;
 
        template<typename DeleteTimelineEventRequestT = Model::DeleteTimelineEventRequest>
        Model::DeleteTimelineEventOutcomeCallable DeleteTimelineEventCallable(const DeleteTimelineEventRequestT& request) const
        {
            return SubmitCallable(&SSMIncidentsClient::DeleteTimelineEvent, request);
        }
 
        template<typename DeleteTimelineEventRequestT = Model::DeleteTimelineEventRequest>
        void DeleteTimelineEventAsync(const DeleteTimelineEventRequestT& request, const DeleteTimelineEventResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMIncidentsClient::DeleteTimelineEvent, request, handler, context);
        }
 
        virtual Model::GetIncidentRecordOutcome GetIncidentRecord(const Model::GetIncidentRecordRequest& request) const;
 
        template<typename GetIncidentRecordRequestT = Model::GetIncidentRecordRequest>
        Model::GetIncidentRecordOutcomeCallable GetIncidentRecordCallable(const GetIncidentRecordRequestT& request) const
        {
            return SubmitCallable(&SSMIncidentsClient::GetIncidentRecord, request);
        }
 
        template<typename GetIncidentRecordRequestT = Model::GetIncidentRecordRequest>
        void GetIncidentRecordAsync(const GetIncidentRecordRequestT& request, const GetIncidentRecordResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMIncidentsClient::GetIncidentRecord, request, handler, context);
        }
 
        virtual Model::GetReplicationSetOutcome GetReplicationSet(const Model::GetReplicationSetRequest& request) const;
 
        template<typename GetReplicationSetRequestT = Model::GetReplicationSetRequest>
        Model::GetReplicationSetOutcomeCallable GetReplicationSetCallable(const GetReplicationSetRequestT& request) const
        {
            return SubmitCallable(&SSMIncidentsClient::GetReplicationSet, request);
        }
 
        template<typename GetReplicationSetRequestT = Model::GetReplicationSetRequest>
        void GetReplicationSetAsync(const GetReplicationSetRequestT& request, const GetReplicationSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMIncidentsClient::GetReplicationSet, request, handler, context);
        }
 
        virtual Model::GetResourcePoliciesOutcome GetResourcePolicies(const Model::GetResourcePoliciesRequest& request) const;
 
        template<typename GetResourcePoliciesRequestT = Model::GetResourcePoliciesRequest>
        Model::GetResourcePoliciesOutcomeCallable GetResourcePoliciesCallable(const GetResourcePoliciesRequestT& request) const
        {
            return SubmitCallable(&SSMIncidentsClient::GetResourcePolicies, request);
        }
 
        template<typename GetResourcePoliciesRequestT = Model::GetResourcePoliciesRequest>
        void GetResourcePoliciesAsync(const GetResourcePoliciesRequestT& request, const GetResourcePoliciesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMIncidentsClient::GetResourcePolicies, request, handler, context);
        }
 
        virtual Model::GetResponsePlanOutcome GetResponsePlan(const Model::GetResponsePlanRequest& request) const;
 
        template<typename GetResponsePlanRequestT = Model::GetResponsePlanRequest>
        Model::GetResponsePlanOutcomeCallable GetResponsePlanCallable(const GetResponsePlanRequestT& request) const
        {
            return SubmitCallable(&SSMIncidentsClient::GetResponsePlan, request);
        }
 
        template<typename GetResponsePlanRequestT = Model::GetResponsePlanRequest>
        void GetResponsePlanAsync(const GetResponsePlanRequestT& request, const GetResponsePlanResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMIncidentsClient::GetResponsePlan, request, handler, context);
        }
 
        virtual Model::GetTimelineEventOutcome GetTimelineEvent(const Model::GetTimelineEventRequest& request) const;
 
        template<typename GetTimelineEventRequestT = Model::GetTimelineEventRequest>
        Model::GetTimelineEventOutcomeCallable GetTimelineEventCallable(const GetTimelineEventRequestT& request) const
        {
            return SubmitCallable(&SSMIncidentsClient::GetTimelineEvent, request);
        }
 
        template<typename GetTimelineEventRequestT = Model::GetTimelineEventRequest>
        void GetTimelineEventAsync(const GetTimelineEventRequestT& request, const GetTimelineEventResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMIncidentsClient::GetTimelineEvent, request, handler, context);
        }
 
        virtual Model::ListIncidentFindingsOutcome ListIncidentFindings(const Model::ListIncidentFindingsRequest& request) const;
 
        template<typename ListIncidentFindingsRequestT = Model::ListIncidentFindingsRequest>
        Model::ListIncidentFindingsOutcomeCallable ListIncidentFindingsCallable(const ListIncidentFindingsRequestT& request) const
        {
            return SubmitCallable(&SSMIncidentsClient::ListIncidentFindings, request);
        }
 
        template<typename ListIncidentFindingsRequestT = Model::ListIncidentFindingsRequest>
        void ListIncidentFindingsAsync(const ListIncidentFindingsRequestT& request, const ListIncidentFindingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMIncidentsClient::ListIncidentFindings, request, handler, context);
        }
 
        virtual Model::ListIncidentRecordsOutcome ListIncidentRecords(const Model::ListIncidentRecordsRequest& request = {}) const;
 
        template<typename ListIncidentRecordsRequestT = Model::ListIncidentRecordsRequest>
        Model::ListIncidentRecordsOutcomeCallable ListIncidentRecordsCallable(const ListIncidentRecordsRequestT& request = {}) const
        {
            return SubmitCallable(&SSMIncidentsClient::ListIncidentRecords, request);
        }
 
        template<typename ListIncidentRecordsRequestT = Model::ListIncidentRecordsRequest>
        void ListIncidentRecordsAsync(const ListIncidentRecordsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListIncidentRecordsRequestT& request = {}) const
        {
            return SubmitAsync(&SSMIncidentsClient::ListIncidentRecords, request, handler, context);
        }
 
        virtual Model::ListRelatedItemsOutcome ListRelatedItems(const Model::ListRelatedItemsRequest& request) const;
 
        template<typename ListRelatedItemsRequestT = Model::ListRelatedItemsRequest>
        Model::ListRelatedItemsOutcomeCallable ListRelatedItemsCallable(const ListRelatedItemsRequestT& request) const
        {
            return SubmitCallable(&SSMIncidentsClient::ListRelatedItems, request);
        }
 
        template<typename ListRelatedItemsRequestT = Model::ListRelatedItemsRequest>
        void ListRelatedItemsAsync(const ListRelatedItemsRequestT& request, const ListRelatedItemsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMIncidentsClient::ListRelatedItems, request, handler, context);
        }
 
        virtual Model::ListReplicationSetsOutcome ListReplicationSets(const Model::ListReplicationSetsRequest& request = {}) const;
 
        template<typename ListReplicationSetsRequestT = Model::ListReplicationSetsRequest>
        Model::ListReplicationSetsOutcomeCallable ListReplicationSetsCallable(const ListReplicationSetsRequestT& request = {}) const
        {
            return SubmitCallable(&SSMIncidentsClient::ListReplicationSets, request);
        }
 
        template<typename ListReplicationSetsRequestT = Model::ListReplicationSetsRequest>
        void ListReplicationSetsAsync(const ListReplicationSetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListReplicationSetsRequestT& request = {}) const
        {
            return SubmitAsync(&SSMIncidentsClient::ListReplicationSets, request, handler, context);
        }
 
        virtual Model::ListResponsePlansOutcome ListResponsePlans(const Model::ListResponsePlansRequest& request = {}) const;
 
        template<typename ListResponsePlansRequestT = Model::ListResponsePlansRequest>
        Model::ListResponsePlansOutcomeCallable ListResponsePlansCallable(const ListResponsePlansRequestT& request = {}) const
        {
            return SubmitCallable(&SSMIncidentsClient::ListResponsePlans, request);
        }
 
        template<typename ListResponsePlansRequestT = Model::ListResponsePlansRequest>
        void ListResponsePlansAsync(const ListResponsePlansResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListResponsePlansRequestT& request = {}) const
        {
            return SubmitAsync(&SSMIncidentsClient::ListResponsePlans, 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(&SSMIncidentsClient::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(&SSMIncidentsClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::ListTimelineEventsOutcome ListTimelineEvents(const Model::ListTimelineEventsRequest& request) const;
 
        template<typename ListTimelineEventsRequestT = Model::ListTimelineEventsRequest>
        Model::ListTimelineEventsOutcomeCallable ListTimelineEventsCallable(const ListTimelineEventsRequestT& request) const
        {
            return SubmitCallable(&SSMIncidentsClient::ListTimelineEvents, request);
        }
 
        template<typename ListTimelineEventsRequestT = Model::ListTimelineEventsRequest>
        void ListTimelineEventsAsync(const ListTimelineEventsRequestT& request, const ListTimelineEventsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMIncidentsClient::ListTimelineEvents, request, handler, context);
        }
 
        virtual Model::PutResourcePolicyOutcome PutResourcePolicy(const Model::PutResourcePolicyRequest& request) const;
 
        template<typename PutResourcePolicyRequestT = Model::PutResourcePolicyRequest>
        Model::PutResourcePolicyOutcomeCallable PutResourcePolicyCallable(const PutResourcePolicyRequestT& request) const
        {
            return SubmitCallable(&SSMIncidentsClient::PutResourcePolicy, request);
        }
 
        template<typename PutResourcePolicyRequestT = Model::PutResourcePolicyRequest>
        void PutResourcePolicyAsync(const PutResourcePolicyRequestT& request, const PutResourcePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMIncidentsClient::PutResourcePolicy, request, handler, context);
        }
 
        virtual Model::StartIncidentOutcome StartIncident(const Model::StartIncidentRequest& request) const;
 
        template<typename StartIncidentRequestT = Model::StartIncidentRequest>
        Model::StartIncidentOutcomeCallable StartIncidentCallable(const StartIncidentRequestT& request) const
        {
            return SubmitCallable(&SSMIncidentsClient::StartIncident, request);
        }
 
        template<typename StartIncidentRequestT = Model::StartIncidentRequest>
        void StartIncidentAsync(const StartIncidentRequestT& request, const StartIncidentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMIncidentsClient::StartIncident, 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(&SSMIncidentsClient::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(&SSMIncidentsClient::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(&SSMIncidentsClient::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(&SSMIncidentsClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateDeletionProtectionOutcome UpdateDeletionProtection(const Model::UpdateDeletionProtectionRequest& request) const;
 
        template<typename UpdateDeletionProtectionRequestT = Model::UpdateDeletionProtectionRequest>
        Model::UpdateDeletionProtectionOutcomeCallable UpdateDeletionProtectionCallable(const UpdateDeletionProtectionRequestT& request) const
        {
            return SubmitCallable(&SSMIncidentsClient::UpdateDeletionProtection, request);
        }
 
        template<typename UpdateDeletionProtectionRequestT = Model::UpdateDeletionProtectionRequest>
        void UpdateDeletionProtectionAsync(const UpdateDeletionProtectionRequestT& request, const UpdateDeletionProtectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMIncidentsClient::UpdateDeletionProtection, request, handler, context);
        }
 
        virtual Model::UpdateIncidentRecordOutcome UpdateIncidentRecord(const Model::UpdateIncidentRecordRequest& request) const;
 
        template<typename UpdateIncidentRecordRequestT = Model::UpdateIncidentRecordRequest>
        Model::UpdateIncidentRecordOutcomeCallable UpdateIncidentRecordCallable(const UpdateIncidentRecordRequestT& request) const
        {
            return SubmitCallable(&SSMIncidentsClient::UpdateIncidentRecord, request);
        }
 
        template<typename UpdateIncidentRecordRequestT = Model::UpdateIncidentRecordRequest>
        void UpdateIncidentRecordAsync(const UpdateIncidentRecordRequestT& request, const UpdateIncidentRecordResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMIncidentsClient::UpdateIncidentRecord, request, handler, context);
        }
 
        virtual Model::UpdateRelatedItemsOutcome UpdateRelatedItems(const Model::UpdateRelatedItemsRequest& request) const;
 
        template<typename UpdateRelatedItemsRequestT = Model::UpdateRelatedItemsRequest>
        Model::UpdateRelatedItemsOutcomeCallable UpdateRelatedItemsCallable(const UpdateRelatedItemsRequestT& request) const
        {
            return SubmitCallable(&SSMIncidentsClient::UpdateRelatedItems, request);
        }
 
        template<typename UpdateRelatedItemsRequestT = Model::UpdateRelatedItemsRequest>
        void UpdateRelatedItemsAsync(const UpdateRelatedItemsRequestT& request, const UpdateRelatedItemsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMIncidentsClient::UpdateRelatedItems, request, handler, context);
        }
 
        virtual Model::UpdateReplicationSetOutcome UpdateReplicationSet(const Model::UpdateReplicationSetRequest& request) const;
 
        template<typename UpdateReplicationSetRequestT = Model::UpdateReplicationSetRequest>
        Model::UpdateReplicationSetOutcomeCallable UpdateReplicationSetCallable(const UpdateReplicationSetRequestT& request) const
        {
            return SubmitCallable(&SSMIncidentsClient::UpdateReplicationSet, request);
        }
 
        template<typename UpdateReplicationSetRequestT = Model::UpdateReplicationSetRequest>
        void UpdateReplicationSetAsync(const UpdateReplicationSetRequestT& request, const UpdateReplicationSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMIncidentsClient::UpdateReplicationSet, request, handler, context);
        }
 
        virtual Model::UpdateResponsePlanOutcome UpdateResponsePlan(const Model::UpdateResponsePlanRequest& request) const;
 
        template<typename UpdateResponsePlanRequestT = Model::UpdateResponsePlanRequest>
        Model::UpdateResponsePlanOutcomeCallable UpdateResponsePlanCallable(const UpdateResponsePlanRequestT& request) const
        {
            return SubmitCallable(&SSMIncidentsClient::UpdateResponsePlan, request);
        }
 
        template<typename UpdateResponsePlanRequestT = Model::UpdateResponsePlanRequest>
        void UpdateResponsePlanAsync(const UpdateResponsePlanRequestT& request, const UpdateResponsePlanResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMIncidentsClient::UpdateResponsePlan, request, handler, context);
        }
 
        virtual Model::UpdateTimelineEventOutcome UpdateTimelineEvent(const Model::UpdateTimelineEventRequest& request) const;
 
        template<typename UpdateTimelineEventRequestT = Model::UpdateTimelineEventRequest>
        Model::UpdateTimelineEventOutcomeCallable UpdateTimelineEventCallable(const UpdateTimelineEventRequestT& request) const
        {
            return SubmitCallable(&SSMIncidentsClient::UpdateTimelineEvent, request);
        }
 
        template<typename UpdateTimelineEventRequestT = Model::UpdateTimelineEventRequest>
        void UpdateTimelineEventAsync(const UpdateTimelineEventRequestT& request, const UpdateTimelineEventResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMIncidentsClient::UpdateTimelineEvent, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<SSMIncidentsEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<SSMIncidentsClient>;
      void init(const SSMIncidentsClientConfiguration& clientConfiguration);
 
      SSMIncidentsClientConfiguration m_clientConfiguration;
      std::shared_ptr<SSMIncidentsEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace SSMIncidents
} // namespace Aws