SyntheticsClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/synthetics/SyntheticsPaginationBase.h>
#include <aws/synthetics/SyntheticsServiceClientModel.h>
#include <aws/synthetics/Synthetics_EXPORTS.h>
 
namespace Aws {
namespace Synthetics {
class AWS_SYNTHETICS_API SyntheticsClient : public Aws::Client::AWSJsonClient,
                                            public Aws::Client::ClientWithAsyncTemplateMethods<SyntheticsClient>,
                                            public SyntheticsPaginationBase<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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual 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