SyntheticsClient.h

 
#pragma once
#include <aws/synthetics/Synthetics_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/synthetics/SyntheticsServiceClientModel.h>
 
namespace Aws
{
namespace Synthetics
{
  class AWS_SYNTHETICS_API SyntheticsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<SyntheticsClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef SyntheticsClientConfiguration ClientConfigurationType;
      typedef SyntheticsEndpointProvider EndpointProviderType;
 
        SyntheticsClient(const Aws::Synthetics::SyntheticsClientConfiguration& clientConfiguration = Aws::Synthetics::SyntheticsClientConfiguration(),
                         std::shared_ptr<SyntheticsEndpointProviderBase> endpointProvider = nullptr);
 
        SyntheticsClient(const Aws::Auth::AWSCredentials& credentials,
                         std::shared_ptr<SyntheticsEndpointProviderBase> endpointProvider = nullptr,
                         const Aws::Synthetics::SyntheticsClientConfiguration& clientConfiguration = Aws::Synthetics::SyntheticsClientConfiguration());
 
        SyntheticsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                         std::shared_ptr<SyntheticsEndpointProviderBase> endpointProvider = nullptr,
                         const Aws::Synthetics::SyntheticsClientConfiguration& clientConfiguration = Aws::Synthetics::SyntheticsClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        SyntheticsClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        SyntheticsClient(const Aws::Auth::AWSCredentials& credentials,
                         const Aws::Client::ClientConfiguration& clientConfiguration);
 
        SyntheticsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                         const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~SyntheticsClient();
 
        virtual Model::AssociateResourceOutcome AssociateResource(const Model::AssociateResourceRequest& request) const;
 
        template<typename AssociateResourceRequestT = Model::AssociateResourceRequest>
        Model::AssociateResourceOutcomeCallable AssociateResourceCallable(const AssociateResourceRequestT& request) const
        {
            return SubmitCallable(&SyntheticsClient::AssociateResource, request);
        }
 
        template<typename AssociateResourceRequestT = Model::AssociateResourceRequest>
        void AssociateResourceAsync(const AssociateResourceRequestT& request, const AssociateResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SyntheticsClient::AssociateResource, request, handler, context);
        }
 
        virtual Model::CreateCanaryOutcome CreateCanary(const Model::CreateCanaryRequest& request) const;
 
        template<typename CreateCanaryRequestT = Model::CreateCanaryRequest>
        Model::CreateCanaryOutcomeCallable CreateCanaryCallable(const CreateCanaryRequestT& request) const
        {
            return SubmitCallable(&SyntheticsClient::CreateCanary, request);
        }
 
        template<typename CreateCanaryRequestT = Model::CreateCanaryRequest>
        void CreateCanaryAsync(const CreateCanaryRequestT& request, const CreateCanaryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SyntheticsClient::CreateCanary, request, handler, context);
        }
 
        virtual Model::CreateGroupOutcome CreateGroup(const Model::CreateGroupRequest& request) const;
 
        template<typename CreateGroupRequestT = Model::CreateGroupRequest>
        Model::CreateGroupOutcomeCallable CreateGroupCallable(const CreateGroupRequestT& request) const
        {
            return SubmitCallable(&SyntheticsClient::CreateGroup, request);
        }
 
        template<typename CreateGroupRequestT = Model::CreateGroupRequest>
        void CreateGroupAsync(const CreateGroupRequestT& request, const CreateGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SyntheticsClient::CreateGroup, request, handler, context);
        }
 
        virtual Model::DeleteCanaryOutcome DeleteCanary(const Model::DeleteCanaryRequest& request) const;
 
        template<typename DeleteCanaryRequestT = Model::DeleteCanaryRequest>
        Model::DeleteCanaryOutcomeCallable DeleteCanaryCallable(const DeleteCanaryRequestT& request) const
        {
            return SubmitCallable(&SyntheticsClient::DeleteCanary, request);
        }
 
        template<typename DeleteCanaryRequestT = Model::DeleteCanaryRequest>
        void DeleteCanaryAsync(const DeleteCanaryRequestT& request, const DeleteCanaryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SyntheticsClient::DeleteCanary, request, handler, context);
        }
 
        virtual Model::DeleteGroupOutcome DeleteGroup(const Model::DeleteGroupRequest& request) const;
 
        template<typename DeleteGroupRequestT = Model::DeleteGroupRequest>
        Model::DeleteGroupOutcomeCallable DeleteGroupCallable(const DeleteGroupRequestT& request) const
        {
            return SubmitCallable(&SyntheticsClient::DeleteGroup, request);
        }
 
        template<typename DeleteGroupRequestT = Model::DeleteGroupRequest>
        void DeleteGroupAsync(const DeleteGroupRequestT& request, const DeleteGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SyntheticsClient::DeleteGroup, request, handler, context);
        }
 
        virtual Model::DescribeCanariesOutcome DescribeCanaries(const Model::DescribeCanariesRequest& request = {}) const;
 
        template<typename DescribeCanariesRequestT = Model::DescribeCanariesRequest>
        Model::DescribeCanariesOutcomeCallable DescribeCanariesCallable(const DescribeCanariesRequestT& request = {}) const
        {
            return SubmitCallable(&SyntheticsClient::DescribeCanaries, request);
        }
 
        template<typename DescribeCanariesRequestT = Model::DescribeCanariesRequest>
        void DescribeCanariesAsync(const DescribeCanariesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeCanariesRequestT& request = {}) const
        {
            return SubmitAsync(&SyntheticsClient::DescribeCanaries, request, handler, context);
        }
 
        virtual Model::DescribeCanariesLastRunOutcome DescribeCanariesLastRun(const Model::DescribeCanariesLastRunRequest& request = {}) const;
 
        template<typename DescribeCanariesLastRunRequestT = Model::DescribeCanariesLastRunRequest>
        Model::DescribeCanariesLastRunOutcomeCallable DescribeCanariesLastRunCallable(const DescribeCanariesLastRunRequestT& request = {}) const
        {
            return SubmitCallable(&SyntheticsClient::DescribeCanariesLastRun, request);
        }
 
        template<typename DescribeCanariesLastRunRequestT = Model::DescribeCanariesLastRunRequest>
        void DescribeCanariesLastRunAsync(const DescribeCanariesLastRunResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeCanariesLastRunRequestT& request = {}) const
        {
            return SubmitAsync(&SyntheticsClient::DescribeCanariesLastRun, request, handler, context);
        }
 
        virtual Model::DescribeRuntimeVersionsOutcome DescribeRuntimeVersions(const Model::DescribeRuntimeVersionsRequest& request = {}) const;
 
        template<typename DescribeRuntimeVersionsRequestT = Model::DescribeRuntimeVersionsRequest>
        Model::DescribeRuntimeVersionsOutcomeCallable DescribeRuntimeVersionsCallable(const DescribeRuntimeVersionsRequestT& request = {}) const
        {
            return SubmitCallable(&SyntheticsClient::DescribeRuntimeVersions, request);
        }
 
        template<typename DescribeRuntimeVersionsRequestT = Model::DescribeRuntimeVersionsRequest>
        void DescribeRuntimeVersionsAsync(const DescribeRuntimeVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeRuntimeVersionsRequestT& request = {}) const
        {
            return SubmitAsync(&SyntheticsClient::DescribeRuntimeVersions, request, handler, context);
        }
 
        virtual Model::DisassociateResourceOutcome DisassociateResource(const Model::DisassociateResourceRequest& request) const;
 
        template<typename DisassociateResourceRequestT = Model::DisassociateResourceRequest>
        Model::DisassociateResourceOutcomeCallable DisassociateResourceCallable(const DisassociateResourceRequestT& request) const
        {
            return SubmitCallable(&SyntheticsClient::DisassociateResource, request);
        }
 
        template<typename DisassociateResourceRequestT = Model::DisassociateResourceRequest>
        void DisassociateResourceAsync(const DisassociateResourceRequestT& request, const DisassociateResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SyntheticsClient::DisassociateResource, request, handler, context);
        }
 
        virtual Model::GetCanaryOutcome GetCanary(const Model::GetCanaryRequest& request) const;
 
        template<typename GetCanaryRequestT = Model::GetCanaryRequest>
        Model::GetCanaryOutcomeCallable GetCanaryCallable(const GetCanaryRequestT& request) const
        {
            return SubmitCallable(&SyntheticsClient::GetCanary, request);
        }
 
        template<typename GetCanaryRequestT = Model::GetCanaryRequest>
        void GetCanaryAsync(const GetCanaryRequestT& request, const GetCanaryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SyntheticsClient::GetCanary, request, handler, context);
        }
 
        virtual Model::GetCanaryRunsOutcome GetCanaryRuns(const Model::GetCanaryRunsRequest& request) const;
 
        template<typename GetCanaryRunsRequestT = Model::GetCanaryRunsRequest>
        Model::GetCanaryRunsOutcomeCallable GetCanaryRunsCallable(const GetCanaryRunsRequestT& request) const
        {
            return SubmitCallable(&SyntheticsClient::GetCanaryRuns, request);
        }
 
        template<typename GetCanaryRunsRequestT = Model::GetCanaryRunsRequest>
        void GetCanaryRunsAsync(const GetCanaryRunsRequestT& request, const GetCanaryRunsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SyntheticsClient::GetCanaryRuns, request, handler, context);
        }
 
        virtual Model::GetGroupOutcome GetGroup(const Model::GetGroupRequest& request) const;
 
        template<typename GetGroupRequestT = Model::GetGroupRequest>
        Model::GetGroupOutcomeCallable GetGroupCallable(const GetGroupRequestT& request) const
        {
            return SubmitCallable(&SyntheticsClient::GetGroup, request);
        }
 
        template<typename GetGroupRequestT = Model::GetGroupRequest>
        void GetGroupAsync(const GetGroupRequestT& request, const GetGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SyntheticsClient::GetGroup, request, handler, context);
        }
 
        virtual Model::ListAssociatedGroupsOutcome ListAssociatedGroups(const Model::ListAssociatedGroupsRequest& request) const;
 
        template<typename ListAssociatedGroupsRequestT = Model::ListAssociatedGroupsRequest>
        Model::ListAssociatedGroupsOutcomeCallable ListAssociatedGroupsCallable(const ListAssociatedGroupsRequestT& request) const
        {
            return SubmitCallable(&SyntheticsClient::ListAssociatedGroups, request);
        }
 
        template<typename ListAssociatedGroupsRequestT = Model::ListAssociatedGroupsRequest>
        void ListAssociatedGroupsAsync(const ListAssociatedGroupsRequestT& request, const ListAssociatedGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SyntheticsClient::ListAssociatedGroups, request, handler, context);
        }
 
        virtual Model::ListGroupResourcesOutcome ListGroupResources(const Model::ListGroupResourcesRequest& request) const;
 
        template<typename ListGroupResourcesRequestT = Model::ListGroupResourcesRequest>
        Model::ListGroupResourcesOutcomeCallable ListGroupResourcesCallable(const ListGroupResourcesRequestT& request) const
        {
            return SubmitCallable(&SyntheticsClient::ListGroupResources, request);
        }
 
        template<typename ListGroupResourcesRequestT = Model::ListGroupResourcesRequest>
        void ListGroupResourcesAsync(const ListGroupResourcesRequestT& request, const ListGroupResourcesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SyntheticsClient::ListGroupResources, request, handler, context);
        }
 
        virtual Model::ListGroupsOutcome ListGroups(const Model::ListGroupsRequest& request = {}) const;
 
        template<typename ListGroupsRequestT = Model::ListGroupsRequest>
        Model::ListGroupsOutcomeCallable ListGroupsCallable(const ListGroupsRequestT& request = {}) const
        {
            return SubmitCallable(&SyntheticsClient::ListGroups, request);
        }
 
        template<typename ListGroupsRequestT = Model::ListGroupsRequest>
        void ListGroupsAsync(const ListGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListGroupsRequestT& request = {}) const
        {
            return SubmitAsync(&SyntheticsClient::ListGroups, 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(&SyntheticsClient::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(&SyntheticsClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::StartCanaryOutcome StartCanary(const Model::StartCanaryRequest& request) const;
 
        template<typename StartCanaryRequestT = Model::StartCanaryRequest>
        Model::StartCanaryOutcomeCallable StartCanaryCallable(const StartCanaryRequestT& request) const
        {
            return SubmitCallable(&SyntheticsClient::StartCanary, request);
        }
 
        template<typename StartCanaryRequestT = Model::StartCanaryRequest>
        void StartCanaryAsync(const StartCanaryRequestT& request, const StartCanaryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SyntheticsClient::StartCanary, request, handler, context);
        }
 
        virtual Model::StartCanaryDryRunOutcome StartCanaryDryRun(const Model::StartCanaryDryRunRequest& request) const;
 
        template<typename StartCanaryDryRunRequestT = Model::StartCanaryDryRunRequest>
        Model::StartCanaryDryRunOutcomeCallable StartCanaryDryRunCallable(const StartCanaryDryRunRequestT& request) const
        {
            return SubmitCallable(&SyntheticsClient::StartCanaryDryRun, request);
        }
 
        template<typename StartCanaryDryRunRequestT = Model::StartCanaryDryRunRequest>
        void StartCanaryDryRunAsync(const StartCanaryDryRunRequestT& request, const StartCanaryDryRunResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SyntheticsClient::StartCanaryDryRun, request, handler, context);
        }
 
        virtual Model::StopCanaryOutcome StopCanary(const Model::StopCanaryRequest& request) const;
 
        template<typename StopCanaryRequestT = Model::StopCanaryRequest>
        Model::StopCanaryOutcomeCallable StopCanaryCallable(const StopCanaryRequestT& request) const
        {
            return SubmitCallable(&SyntheticsClient::StopCanary, request);
        }
 
        template<typename StopCanaryRequestT = Model::StopCanaryRequest>
        void StopCanaryAsync(const StopCanaryRequestT& request, const StopCanaryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SyntheticsClient::StopCanary, 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(&SyntheticsClient::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(&SyntheticsClient::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(&SyntheticsClient::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(&SyntheticsClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateCanaryOutcome UpdateCanary(const Model::UpdateCanaryRequest& request) const;
 
        template<typename UpdateCanaryRequestT = Model::UpdateCanaryRequest>
        Model::UpdateCanaryOutcomeCallable UpdateCanaryCallable(const UpdateCanaryRequestT& request) const
        {
            return SubmitCallable(&SyntheticsClient::UpdateCanary, request);
        }
 
        template<typename UpdateCanaryRequestT = Model::UpdateCanaryRequest>
        void UpdateCanaryAsync(const UpdateCanaryRequestT& request, const UpdateCanaryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SyntheticsClient::UpdateCanary, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<SyntheticsEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<SyntheticsClient>;
      void init(const SyntheticsClientConfiguration& clientConfiguration);
 
      SyntheticsClientConfiguration m_clientConfiguration;
      std::shared_ptr<SyntheticsEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace Synthetics
} // namespace Aws