SSMContactsClient.h

 
#pragma once
#include <aws/ssm-contacts/SSMContacts_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-contacts/SSMContactsServiceClientModel.h>
 
namespace Aws
{
namespace SSMContacts
{
  class AWS_SSMCONTACTS_API SSMContactsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<SSMContactsClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef SSMContactsClientConfiguration ClientConfigurationType;
      typedef SSMContactsEndpointProvider EndpointProviderType;
 
        SSMContactsClient(const Aws::SSMContacts::SSMContactsClientConfiguration& clientConfiguration = Aws::SSMContacts::SSMContactsClientConfiguration(),
                          std::shared_ptr<SSMContactsEndpointProviderBase> endpointProvider = nullptr);
 
        SSMContactsClient(const Aws::Auth::AWSCredentials& credentials,
                          std::shared_ptr<SSMContactsEndpointProviderBase> endpointProvider = nullptr,
                          const Aws::SSMContacts::SSMContactsClientConfiguration& clientConfiguration = Aws::SSMContacts::SSMContactsClientConfiguration());
 
        SSMContactsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                          std::shared_ptr<SSMContactsEndpointProviderBase> endpointProvider = nullptr,
                          const Aws::SSMContacts::SSMContactsClientConfiguration& clientConfiguration = Aws::SSMContacts::SSMContactsClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        SSMContactsClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        SSMContactsClient(const Aws::Auth::AWSCredentials& credentials,
                          const Aws::Client::ClientConfiguration& clientConfiguration);
 
        SSMContactsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                          const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~SSMContactsClient();
 
        virtual Model::AcceptPageOutcome AcceptPage(const Model::AcceptPageRequest& request) const;
 
        template<typename AcceptPageRequestT = Model::AcceptPageRequest>
        Model::AcceptPageOutcomeCallable AcceptPageCallable(const AcceptPageRequestT& request) const
        {
            return SubmitCallable(&SSMContactsClient::AcceptPage, request);
        }
 
        template<typename AcceptPageRequestT = Model::AcceptPageRequest>
        void AcceptPageAsync(const AcceptPageRequestT& request, const AcceptPageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMContactsClient::AcceptPage, request, handler, context);
        }
 
        virtual Model::ActivateContactChannelOutcome ActivateContactChannel(const Model::ActivateContactChannelRequest& request) const;
 
        template<typename ActivateContactChannelRequestT = Model::ActivateContactChannelRequest>
        Model::ActivateContactChannelOutcomeCallable ActivateContactChannelCallable(const ActivateContactChannelRequestT& request) const
        {
            return SubmitCallable(&SSMContactsClient::ActivateContactChannel, request);
        }
 
        template<typename ActivateContactChannelRequestT = Model::ActivateContactChannelRequest>
        void ActivateContactChannelAsync(const ActivateContactChannelRequestT& request, const ActivateContactChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMContactsClient::ActivateContactChannel, request, handler, context);
        }
 
        virtual Model::CreateContactOutcome CreateContact(const Model::CreateContactRequest& request) const;
 
        template<typename CreateContactRequestT = Model::CreateContactRequest>
        Model::CreateContactOutcomeCallable CreateContactCallable(const CreateContactRequestT& request) const
        {
            return SubmitCallable(&SSMContactsClient::CreateContact, request);
        }
 
        template<typename CreateContactRequestT = Model::CreateContactRequest>
        void CreateContactAsync(const CreateContactRequestT& request, const CreateContactResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMContactsClient::CreateContact, request, handler, context);
        }
 
        virtual Model::CreateContactChannelOutcome CreateContactChannel(const Model::CreateContactChannelRequest& request) const;
 
        template<typename CreateContactChannelRequestT = Model::CreateContactChannelRequest>
        Model::CreateContactChannelOutcomeCallable CreateContactChannelCallable(const CreateContactChannelRequestT& request) const
        {
            return SubmitCallable(&SSMContactsClient::CreateContactChannel, request);
        }
 
        template<typename CreateContactChannelRequestT = Model::CreateContactChannelRequest>
        void CreateContactChannelAsync(const CreateContactChannelRequestT& request, const CreateContactChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMContactsClient::CreateContactChannel, request, handler, context);
        }
 
        virtual Model::CreateRotationOutcome CreateRotation(const Model::CreateRotationRequest& request) const;
 
        template<typename CreateRotationRequestT = Model::CreateRotationRequest>
        Model::CreateRotationOutcomeCallable CreateRotationCallable(const CreateRotationRequestT& request) const
        {
            return SubmitCallable(&SSMContactsClient::CreateRotation, request);
        }
 
        template<typename CreateRotationRequestT = Model::CreateRotationRequest>
        void CreateRotationAsync(const CreateRotationRequestT& request, const CreateRotationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMContactsClient::CreateRotation, request, handler, context);
        }
 
        virtual Model::CreateRotationOverrideOutcome CreateRotationOverride(const Model::CreateRotationOverrideRequest& request) const;
 
        template<typename CreateRotationOverrideRequestT = Model::CreateRotationOverrideRequest>
        Model::CreateRotationOverrideOutcomeCallable CreateRotationOverrideCallable(const CreateRotationOverrideRequestT& request) const
        {
            return SubmitCallable(&SSMContactsClient::CreateRotationOverride, request);
        }
 
        template<typename CreateRotationOverrideRequestT = Model::CreateRotationOverrideRequest>
        void CreateRotationOverrideAsync(const CreateRotationOverrideRequestT& request, const CreateRotationOverrideResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMContactsClient::CreateRotationOverride, request, handler, context);
        }
 
        virtual Model::DeactivateContactChannelOutcome DeactivateContactChannel(const Model::DeactivateContactChannelRequest& request) const;
 
        template<typename DeactivateContactChannelRequestT = Model::DeactivateContactChannelRequest>
        Model::DeactivateContactChannelOutcomeCallable DeactivateContactChannelCallable(const DeactivateContactChannelRequestT& request) const
        {
            return SubmitCallable(&SSMContactsClient::DeactivateContactChannel, request);
        }
 
        template<typename DeactivateContactChannelRequestT = Model::DeactivateContactChannelRequest>
        void DeactivateContactChannelAsync(const DeactivateContactChannelRequestT& request, const DeactivateContactChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMContactsClient::DeactivateContactChannel, request, handler, context);
        }
 
        virtual Model::DeleteContactOutcome DeleteContact(const Model::DeleteContactRequest& request) const;
 
        template<typename DeleteContactRequestT = Model::DeleteContactRequest>
        Model::DeleteContactOutcomeCallable DeleteContactCallable(const DeleteContactRequestT& request) const
        {
            return SubmitCallable(&SSMContactsClient::DeleteContact, request);
        }
 
        template<typename DeleteContactRequestT = Model::DeleteContactRequest>
        void DeleteContactAsync(const DeleteContactRequestT& request, const DeleteContactResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMContactsClient::DeleteContact, request, handler, context);
        }
 
        virtual Model::DeleteContactChannelOutcome DeleteContactChannel(const Model::DeleteContactChannelRequest& request) const;
 
        template<typename DeleteContactChannelRequestT = Model::DeleteContactChannelRequest>
        Model::DeleteContactChannelOutcomeCallable DeleteContactChannelCallable(const DeleteContactChannelRequestT& request) const
        {
            return SubmitCallable(&SSMContactsClient::DeleteContactChannel, request);
        }
 
        template<typename DeleteContactChannelRequestT = Model::DeleteContactChannelRequest>
        void DeleteContactChannelAsync(const DeleteContactChannelRequestT& request, const DeleteContactChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMContactsClient::DeleteContactChannel, request, handler, context);
        }
 
        virtual Model::DeleteRotationOutcome DeleteRotation(const Model::DeleteRotationRequest& request) const;
 
        template<typename DeleteRotationRequestT = Model::DeleteRotationRequest>
        Model::DeleteRotationOutcomeCallable DeleteRotationCallable(const DeleteRotationRequestT& request) const
        {
            return SubmitCallable(&SSMContactsClient::DeleteRotation, request);
        }
 
        template<typename DeleteRotationRequestT = Model::DeleteRotationRequest>
        void DeleteRotationAsync(const DeleteRotationRequestT& request, const DeleteRotationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMContactsClient::DeleteRotation, request, handler, context);
        }
 
        virtual Model::DeleteRotationOverrideOutcome DeleteRotationOverride(const Model::DeleteRotationOverrideRequest& request) const;
 
        template<typename DeleteRotationOverrideRequestT = Model::DeleteRotationOverrideRequest>
        Model::DeleteRotationOverrideOutcomeCallable DeleteRotationOverrideCallable(const DeleteRotationOverrideRequestT& request) const
        {
            return SubmitCallable(&SSMContactsClient::DeleteRotationOverride, request);
        }
 
        template<typename DeleteRotationOverrideRequestT = Model::DeleteRotationOverrideRequest>
        void DeleteRotationOverrideAsync(const DeleteRotationOverrideRequestT& request, const DeleteRotationOverrideResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMContactsClient::DeleteRotationOverride, request, handler, context);
        }
 
        virtual Model::DescribeEngagementOutcome DescribeEngagement(const Model::DescribeEngagementRequest& request) const;
 
        template<typename DescribeEngagementRequestT = Model::DescribeEngagementRequest>
        Model::DescribeEngagementOutcomeCallable DescribeEngagementCallable(const DescribeEngagementRequestT& request) const
        {
            return SubmitCallable(&SSMContactsClient::DescribeEngagement, request);
        }
 
        template<typename DescribeEngagementRequestT = Model::DescribeEngagementRequest>
        void DescribeEngagementAsync(const DescribeEngagementRequestT& request, const DescribeEngagementResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMContactsClient::DescribeEngagement, request, handler, context);
        }
 
        virtual Model::DescribePageOutcome DescribePage(const Model::DescribePageRequest& request) const;
 
        template<typename DescribePageRequestT = Model::DescribePageRequest>
        Model::DescribePageOutcomeCallable DescribePageCallable(const DescribePageRequestT& request) const
        {
            return SubmitCallable(&SSMContactsClient::DescribePage, request);
        }
 
        template<typename DescribePageRequestT = Model::DescribePageRequest>
        void DescribePageAsync(const DescribePageRequestT& request, const DescribePageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMContactsClient::DescribePage, request, handler, context);
        }
 
        virtual Model::GetContactOutcome GetContact(const Model::GetContactRequest& request) const;
 
        template<typename GetContactRequestT = Model::GetContactRequest>
        Model::GetContactOutcomeCallable GetContactCallable(const GetContactRequestT& request) const
        {
            return SubmitCallable(&SSMContactsClient::GetContact, request);
        }
 
        template<typename GetContactRequestT = Model::GetContactRequest>
        void GetContactAsync(const GetContactRequestT& request, const GetContactResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMContactsClient::GetContact, request, handler, context);
        }
 
        virtual Model::GetContactChannelOutcome GetContactChannel(const Model::GetContactChannelRequest& request) const;
 
        template<typename GetContactChannelRequestT = Model::GetContactChannelRequest>
        Model::GetContactChannelOutcomeCallable GetContactChannelCallable(const GetContactChannelRequestT& request) const
        {
            return SubmitCallable(&SSMContactsClient::GetContactChannel, request);
        }
 
        template<typename GetContactChannelRequestT = Model::GetContactChannelRequest>
        void GetContactChannelAsync(const GetContactChannelRequestT& request, const GetContactChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMContactsClient::GetContactChannel, request, handler, context);
        }
 
        virtual Model::GetContactPolicyOutcome GetContactPolicy(const Model::GetContactPolicyRequest& request) const;
 
        template<typename GetContactPolicyRequestT = Model::GetContactPolicyRequest>
        Model::GetContactPolicyOutcomeCallable GetContactPolicyCallable(const GetContactPolicyRequestT& request) const
        {
            return SubmitCallable(&SSMContactsClient::GetContactPolicy, request);
        }
 
        template<typename GetContactPolicyRequestT = Model::GetContactPolicyRequest>
        void GetContactPolicyAsync(const GetContactPolicyRequestT& request, const GetContactPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMContactsClient::GetContactPolicy, request, handler, context);
        }
 
        virtual Model::GetRotationOutcome GetRotation(const Model::GetRotationRequest& request) const;
 
        template<typename GetRotationRequestT = Model::GetRotationRequest>
        Model::GetRotationOutcomeCallable GetRotationCallable(const GetRotationRequestT& request) const
        {
            return SubmitCallable(&SSMContactsClient::GetRotation, request);
        }
 
        template<typename GetRotationRequestT = Model::GetRotationRequest>
        void GetRotationAsync(const GetRotationRequestT& request, const GetRotationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMContactsClient::GetRotation, request, handler, context);
        }
 
        virtual Model::GetRotationOverrideOutcome GetRotationOverride(const Model::GetRotationOverrideRequest& request) const;
 
        template<typename GetRotationOverrideRequestT = Model::GetRotationOverrideRequest>
        Model::GetRotationOverrideOutcomeCallable GetRotationOverrideCallable(const GetRotationOverrideRequestT& request) const
        {
            return SubmitCallable(&SSMContactsClient::GetRotationOverride, request);
        }
 
        template<typename GetRotationOverrideRequestT = Model::GetRotationOverrideRequest>
        void GetRotationOverrideAsync(const GetRotationOverrideRequestT& request, const GetRotationOverrideResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMContactsClient::GetRotationOverride, request, handler, context);
        }
 
        virtual Model::ListContactChannelsOutcome ListContactChannels(const Model::ListContactChannelsRequest& request) const;
 
        template<typename ListContactChannelsRequestT = Model::ListContactChannelsRequest>
        Model::ListContactChannelsOutcomeCallable ListContactChannelsCallable(const ListContactChannelsRequestT& request) const
        {
            return SubmitCallable(&SSMContactsClient::ListContactChannels, request);
        }
 
        template<typename ListContactChannelsRequestT = Model::ListContactChannelsRequest>
        void ListContactChannelsAsync(const ListContactChannelsRequestT& request, const ListContactChannelsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMContactsClient::ListContactChannels, request, handler, context);
        }
 
        virtual Model::ListContactsOutcome ListContacts(const Model::ListContactsRequest& request = {}) const;
 
        template<typename ListContactsRequestT = Model::ListContactsRequest>
        Model::ListContactsOutcomeCallable ListContactsCallable(const ListContactsRequestT& request = {}) const
        {
            return SubmitCallable(&SSMContactsClient::ListContacts, request);
        }
 
        template<typename ListContactsRequestT = Model::ListContactsRequest>
        void ListContactsAsync(const ListContactsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListContactsRequestT& request = {}) const
        {
            return SubmitAsync(&SSMContactsClient::ListContacts, request, handler, context);
        }
 
        virtual Model::ListEngagementsOutcome ListEngagements(const Model::ListEngagementsRequest& request = {}) const;
 
        template<typename ListEngagementsRequestT = Model::ListEngagementsRequest>
        Model::ListEngagementsOutcomeCallable ListEngagementsCallable(const ListEngagementsRequestT& request = {}) const
        {
            return SubmitCallable(&SSMContactsClient::ListEngagements, request);
        }
 
        template<typename ListEngagementsRequestT = Model::ListEngagementsRequest>
        void ListEngagementsAsync(const ListEngagementsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListEngagementsRequestT& request = {}) const
        {
            return SubmitAsync(&SSMContactsClient::ListEngagements, request, handler, context);
        }
 
        virtual Model::ListPageReceiptsOutcome ListPageReceipts(const Model::ListPageReceiptsRequest& request) const;
 
        template<typename ListPageReceiptsRequestT = Model::ListPageReceiptsRequest>
        Model::ListPageReceiptsOutcomeCallable ListPageReceiptsCallable(const ListPageReceiptsRequestT& request) const
        {
            return SubmitCallable(&SSMContactsClient::ListPageReceipts, request);
        }
 
        template<typename ListPageReceiptsRequestT = Model::ListPageReceiptsRequest>
        void ListPageReceiptsAsync(const ListPageReceiptsRequestT& request, const ListPageReceiptsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMContactsClient::ListPageReceipts, request, handler, context);
        }
 
        virtual Model::ListPageResolutionsOutcome ListPageResolutions(const Model::ListPageResolutionsRequest& request) const;
 
        template<typename ListPageResolutionsRequestT = Model::ListPageResolutionsRequest>
        Model::ListPageResolutionsOutcomeCallable ListPageResolutionsCallable(const ListPageResolutionsRequestT& request) const
        {
            return SubmitCallable(&SSMContactsClient::ListPageResolutions, request);
        }
 
        template<typename ListPageResolutionsRequestT = Model::ListPageResolutionsRequest>
        void ListPageResolutionsAsync(const ListPageResolutionsRequestT& request, const ListPageResolutionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMContactsClient::ListPageResolutions, request, handler, context);
        }
 
        virtual Model::ListPagesByContactOutcome ListPagesByContact(const Model::ListPagesByContactRequest& request) const;
 
        template<typename ListPagesByContactRequestT = Model::ListPagesByContactRequest>
        Model::ListPagesByContactOutcomeCallable ListPagesByContactCallable(const ListPagesByContactRequestT& request) const
        {
            return SubmitCallable(&SSMContactsClient::ListPagesByContact, request);
        }
 
        template<typename ListPagesByContactRequestT = Model::ListPagesByContactRequest>
        void ListPagesByContactAsync(const ListPagesByContactRequestT& request, const ListPagesByContactResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMContactsClient::ListPagesByContact, request, handler, context);
        }
 
        virtual Model::ListPagesByEngagementOutcome ListPagesByEngagement(const Model::ListPagesByEngagementRequest& request) const;
 
        template<typename ListPagesByEngagementRequestT = Model::ListPagesByEngagementRequest>
        Model::ListPagesByEngagementOutcomeCallable ListPagesByEngagementCallable(const ListPagesByEngagementRequestT& request) const
        {
            return SubmitCallable(&SSMContactsClient::ListPagesByEngagement, request);
        }
 
        template<typename ListPagesByEngagementRequestT = Model::ListPagesByEngagementRequest>
        void ListPagesByEngagementAsync(const ListPagesByEngagementRequestT& request, const ListPagesByEngagementResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMContactsClient::ListPagesByEngagement, request, handler, context);
        }
 
        virtual Model::ListPreviewRotationShiftsOutcome ListPreviewRotationShifts(const Model::ListPreviewRotationShiftsRequest& request) const;
 
        template<typename ListPreviewRotationShiftsRequestT = Model::ListPreviewRotationShiftsRequest>
        Model::ListPreviewRotationShiftsOutcomeCallable ListPreviewRotationShiftsCallable(const ListPreviewRotationShiftsRequestT& request) const
        {
            return SubmitCallable(&SSMContactsClient::ListPreviewRotationShifts, request);
        }
 
        template<typename ListPreviewRotationShiftsRequestT = Model::ListPreviewRotationShiftsRequest>
        void ListPreviewRotationShiftsAsync(const ListPreviewRotationShiftsRequestT& request, const ListPreviewRotationShiftsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMContactsClient::ListPreviewRotationShifts, request, handler, context);
        }
 
        virtual Model::ListRotationOverridesOutcome ListRotationOverrides(const Model::ListRotationOverridesRequest& request) const;
 
        template<typename ListRotationOverridesRequestT = Model::ListRotationOverridesRequest>
        Model::ListRotationOverridesOutcomeCallable ListRotationOverridesCallable(const ListRotationOverridesRequestT& request) const
        {
            return SubmitCallable(&SSMContactsClient::ListRotationOverrides, request);
        }
 
        template<typename ListRotationOverridesRequestT = Model::ListRotationOverridesRequest>
        void ListRotationOverridesAsync(const ListRotationOverridesRequestT& request, const ListRotationOverridesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMContactsClient::ListRotationOverrides, request, handler, context);
        }
 
        virtual Model::ListRotationShiftsOutcome ListRotationShifts(const Model::ListRotationShiftsRequest& request) const;
 
        template<typename ListRotationShiftsRequestT = Model::ListRotationShiftsRequest>
        Model::ListRotationShiftsOutcomeCallable ListRotationShiftsCallable(const ListRotationShiftsRequestT& request) const
        {
            return SubmitCallable(&SSMContactsClient::ListRotationShifts, request);
        }
 
        template<typename ListRotationShiftsRequestT = Model::ListRotationShiftsRequest>
        void ListRotationShiftsAsync(const ListRotationShiftsRequestT& request, const ListRotationShiftsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMContactsClient::ListRotationShifts, request, handler, context);
        }
 
        virtual Model::ListRotationsOutcome ListRotations(const Model::ListRotationsRequest& request = {}) const;
 
        template<typename ListRotationsRequestT = Model::ListRotationsRequest>
        Model::ListRotationsOutcomeCallable ListRotationsCallable(const ListRotationsRequestT& request = {}) const
        {
            return SubmitCallable(&SSMContactsClient::ListRotations, request);
        }
 
        template<typename ListRotationsRequestT = Model::ListRotationsRequest>
        void ListRotationsAsync(const ListRotationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListRotationsRequestT& request = {}) const
        {
            return SubmitAsync(&SSMContactsClient::ListRotations, 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(&SSMContactsClient::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(&SSMContactsClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::PutContactPolicyOutcome PutContactPolicy(const Model::PutContactPolicyRequest& request) const;
 
        template<typename PutContactPolicyRequestT = Model::PutContactPolicyRequest>
        Model::PutContactPolicyOutcomeCallable PutContactPolicyCallable(const PutContactPolicyRequestT& request) const
        {
            return SubmitCallable(&SSMContactsClient::PutContactPolicy, request);
        }
 
        template<typename PutContactPolicyRequestT = Model::PutContactPolicyRequest>
        void PutContactPolicyAsync(const PutContactPolicyRequestT& request, const PutContactPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMContactsClient::PutContactPolicy, request, handler, context);
        }
 
        virtual Model::SendActivationCodeOutcome SendActivationCode(const Model::SendActivationCodeRequest& request) const;
 
        template<typename SendActivationCodeRequestT = Model::SendActivationCodeRequest>
        Model::SendActivationCodeOutcomeCallable SendActivationCodeCallable(const SendActivationCodeRequestT& request) const
        {
            return SubmitCallable(&SSMContactsClient::SendActivationCode, request);
        }
 
        template<typename SendActivationCodeRequestT = Model::SendActivationCodeRequest>
        void SendActivationCodeAsync(const SendActivationCodeRequestT& request, const SendActivationCodeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMContactsClient::SendActivationCode, request, handler, context);
        }
 
        virtual Model::StartEngagementOutcome StartEngagement(const Model::StartEngagementRequest& request) const;
 
        template<typename StartEngagementRequestT = Model::StartEngagementRequest>
        Model::StartEngagementOutcomeCallable StartEngagementCallable(const StartEngagementRequestT& request) const
        {
            return SubmitCallable(&SSMContactsClient::StartEngagement, request);
        }
 
        template<typename StartEngagementRequestT = Model::StartEngagementRequest>
        void StartEngagementAsync(const StartEngagementRequestT& request, const StartEngagementResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMContactsClient::StartEngagement, request, handler, context);
        }
 
        virtual Model::StopEngagementOutcome StopEngagement(const Model::StopEngagementRequest& request) const;
 
        template<typename StopEngagementRequestT = Model::StopEngagementRequest>
        Model::StopEngagementOutcomeCallable StopEngagementCallable(const StopEngagementRequestT& request) const
        {
            return SubmitCallable(&SSMContactsClient::StopEngagement, request);
        }
 
        template<typename StopEngagementRequestT = Model::StopEngagementRequest>
        void StopEngagementAsync(const StopEngagementRequestT& request, const StopEngagementResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMContactsClient::StopEngagement, 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(&SSMContactsClient::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(&SSMContactsClient::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(&SSMContactsClient::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(&SSMContactsClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateContactOutcome UpdateContact(const Model::UpdateContactRequest& request) const;
 
        template<typename UpdateContactRequestT = Model::UpdateContactRequest>
        Model::UpdateContactOutcomeCallable UpdateContactCallable(const UpdateContactRequestT& request) const
        {
            return SubmitCallable(&SSMContactsClient::UpdateContact, request);
        }
 
        template<typename UpdateContactRequestT = Model::UpdateContactRequest>
        void UpdateContactAsync(const UpdateContactRequestT& request, const UpdateContactResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMContactsClient::UpdateContact, request, handler, context);
        }
 
        virtual Model::UpdateContactChannelOutcome UpdateContactChannel(const Model::UpdateContactChannelRequest& request) const;
 
        template<typename UpdateContactChannelRequestT = Model::UpdateContactChannelRequest>
        Model::UpdateContactChannelOutcomeCallable UpdateContactChannelCallable(const UpdateContactChannelRequestT& request) const
        {
            return SubmitCallable(&SSMContactsClient::UpdateContactChannel, request);
        }
 
        template<typename UpdateContactChannelRequestT = Model::UpdateContactChannelRequest>
        void UpdateContactChannelAsync(const UpdateContactChannelRequestT& request, const UpdateContactChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMContactsClient::UpdateContactChannel, request, handler, context);
        }
 
        virtual Model::UpdateRotationOutcome UpdateRotation(const Model::UpdateRotationRequest& request) const;
 
        template<typename UpdateRotationRequestT = Model::UpdateRotationRequest>
        Model::UpdateRotationOutcomeCallable UpdateRotationCallable(const UpdateRotationRequestT& request) const
        {
            return SubmitCallable(&SSMContactsClient::UpdateRotation, request);
        }
 
        template<typename UpdateRotationRequestT = Model::UpdateRotationRequest>
        void UpdateRotationAsync(const UpdateRotationRequestT& request, const UpdateRotationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SSMContactsClient::UpdateRotation, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<SSMContactsEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<SSMContactsClient>;
      void init(const SSMContactsClientConfiguration& clientConfiguration);
 
      SSMContactsClientConfiguration m_clientConfiguration;
      std::shared_ptr<SSMContactsEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace SSMContacts
} // namespace Aws