AIOpsClient.h

 
#pragma once
#include <aws/aiops/AIOpsPaginationBase.h>
#include <aws/aiops/AIOpsServiceClientModel.h>
#include <aws/aiops/AIOpsWaiter.h>
#include <aws/aiops/AIOps_EXPORTS.h>
#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>
 
namespace Aws {
namespace AIOps {
class AWS_AIOPS_API AIOpsClient : public Aws::Client::AWSJsonClient,
                                  public Aws::Client::ClientWithAsyncTemplateMethods<AIOpsClient>,
                                  public AIOpsPaginationBase<AIOpsClient>,
                                  public AIOpsWaiter<AIOpsClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef AIOpsClientConfiguration ClientConfigurationType;
  typedef AIOpsEndpointProvider EndpointProviderType;
 
  AIOpsClient(const Aws::AIOps::AIOpsClientConfiguration& clientConfiguration = Aws::AIOps::AIOpsClientConfiguration(),
              std::shared_ptr<AIOpsEndpointProviderBase> endpointProvider = nullptr);
 
  AIOpsClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<AIOpsEndpointProviderBase> endpointProvider = nullptr,
              const Aws::AIOps::AIOpsClientConfiguration& clientConfiguration = Aws::AIOps::AIOpsClientConfiguration());
 
  AIOpsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
              std::shared_ptr<AIOpsEndpointProviderBase> endpointProvider = nullptr,
              const Aws::AIOps::AIOpsClientConfiguration& clientConfiguration = Aws::AIOps::AIOpsClientConfiguration());
 
  /* Legacy constructors due deprecation */
  AIOpsClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  AIOpsClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  AIOpsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
              const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~AIOpsClient();
 
  virtual Model::CreateInvestigationGroupOutcome CreateInvestigationGroup(const Model::CreateInvestigationGroupRequest& request) const;
 
  template <typename CreateInvestigationGroupRequestT = Model::CreateInvestigationGroupRequest>
  Model::CreateInvestigationGroupOutcomeCallable CreateInvestigationGroupCallable(const CreateInvestigationGroupRequestT& request) const {
    return SubmitCallable(&AIOpsClient::CreateInvestigationGroup, request);
  }
 
  template <typename CreateInvestigationGroupRequestT = Model::CreateInvestigationGroupRequest>
  void CreateInvestigationGroupAsync(const CreateInvestigationGroupRequestT& request,
                                     const CreateInvestigationGroupResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AIOpsClient::CreateInvestigationGroup, request, handler, context);
  }
 
  virtual Model::DeleteInvestigationGroupOutcome DeleteInvestigationGroup(const Model::DeleteInvestigationGroupRequest& request) const;
 
  template <typename DeleteInvestigationGroupRequestT = Model::DeleteInvestigationGroupRequest>
  Model::DeleteInvestigationGroupOutcomeCallable DeleteInvestigationGroupCallable(const DeleteInvestigationGroupRequestT& request) const {
    return SubmitCallable(&AIOpsClient::DeleteInvestigationGroup, request);
  }
 
  template <typename DeleteInvestigationGroupRequestT = Model::DeleteInvestigationGroupRequest>
  void DeleteInvestigationGroupAsync(const DeleteInvestigationGroupRequestT& request,
                                     const DeleteInvestigationGroupResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AIOpsClient::DeleteInvestigationGroup, request, handler, context);
  }
 
  virtual Model::DeleteInvestigationGroupPolicyOutcome DeleteInvestigationGroupPolicy(
      const Model::DeleteInvestigationGroupPolicyRequest& request) const;
 
  template <typename DeleteInvestigationGroupPolicyRequestT = Model::DeleteInvestigationGroupPolicyRequest>
  Model::DeleteInvestigationGroupPolicyOutcomeCallable DeleteInvestigationGroupPolicyCallable(
      const DeleteInvestigationGroupPolicyRequestT& request) const {
    return SubmitCallable(&AIOpsClient::DeleteInvestigationGroupPolicy, request);
  }
 
  template <typename DeleteInvestigationGroupPolicyRequestT = Model::DeleteInvestigationGroupPolicyRequest>
  void DeleteInvestigationGroupPolicyAsync(const DeleteInvestigationGroupPolicyRequestT& request,
                                           const DeleteInvestigationGroupPolicyResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AIOpsClient::DeleteInvestigationGroupPolicy, request, handler, context);
  }
 
  virtual Model::GetInvestigationGroupOutcome GetInvestigationGroup(const Model::GetInvestigationGroupRequest& request) const;
 
  template <typename GetInvestigationGroupRequestT = Model::GetInvestigationGroupRequest>
  Model::GetInvestigationGroupOutcomeCallable GetInvestigationGroupCallable(const GetInvestigationGroupRequestT& request) const {
    return SubmitCallable(&AIOpsClient::GetInvestigationGroup, request);
  }
 
  template <typename GetInvestigationGroupRequestT = Model::GetInvestigationGroupRequest>
  void GetInvestigationGroupAsync(const GetInvestigationGroupRequestT& request, const GetInvestigationGroupResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AIOpsClient::GetInvestigationGroup, request, handler, context);
  }
 
  virtual Model::GetInvestigationGroupPolicyOutcome GetInvestigationGroupPolicy(
      const Model::GetInvestigationGroupPolicyRequest& request) const;
 
  template <typename GetInvestigationGroupPolicyRequestT = Model::GetInvestigationGroupPolicyRequest>
  Model::GetInvestigationGroupPolicyOutcomeCallable GetInvestigationGroupPolicyCallable(
      const GetInvestigationGroupPolicyRequestT& request) const {
    return SubmitCallable(&AIOpsClient::GetInvestigationGroupPolicy, request);
  }
 
  template <typename GetInvestigationGroupPolicyRequestT = Model::GetInvestigationGroupPolicyRequest>
  void GetInvestigationGroupPolicyAsync(const GetInvestigationGroupPolicyRequestT& request,
                                        const GetInvestigationGroupPolicyResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AIOpsClient::GetInvestigationGroupPolicy, request, handler, context);
  }
 
  virtual Model::ListInvestigationGroupsOutcome ListInvestigationGroups(const Model::ListInvestigationGroupsRequest& request = {}) const;
 
  template <typename ListInvestigationGroupsRequestT = Model::ListInvestigationGroupsRequest>
  Model::ListInvestigationGroupsOutcomeCallable ListInvestigationGroupsCallable(const ListInvestigationGroupsRequestT& request = {}) const {
    return SubmitCallable(&AIOpsClient::ListInvestigationGroups, request);
  }
 
  template <typename ListInvestigationGroupsRequestT = Model::ListInvestigationGroupsRequest>
  void ListInvestigationGroupsAsync(const ListInvestigationGroupsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const ListInvestigationGroupsRequestT& request = {}) const {
    return SubmitAsync(&AIOpsClient::ListInvestigationGroups, 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(&AIOpsClient::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(&AIOpsClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::PutInvestigationGroupPolicyOutcome PutInvestigationGroupPolicy(
      const Model::PutInvestigationGroupPolicyRequest& request) const;
 
  template <typename PutInvestigationGroupPolicyRequestT = Model::PutInvestigationGroupPolicyRequest>
  Model::PutInvestigationGroupPolicyOutcomeCallable PutInvestigationGroupPolicyCallable(
      const PutInvestigationGroupPolicyRequestT& request) const {
    return SubmitCallable(&AIOpsClient::PutInvestigationGroupPolicy, request);
  }
 
  template <typename PutInvestigationGroupPolicyRequestT = Model::PutInvestigationGroupPolicyRequest>
  void PutInvestigationGroupPolicyAsync(const PutInvestigationGroupPolicyRequestT& request,
                                        const PutInvestigationGroupPolicyResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AIOpsClient::PutInvestigationGroupPolicy, 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(&AIOpsClient::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(&AIOpsClient::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(&AIOpsClient::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(&AIOpsClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateInvestigationGroupOutcome UpdateInvestigationGroup(const Model::UpdateInvestigationGroupRequest& request) const;
 
  template <typename UpdateInvestigationGroupRequestT = Model::UpdateInvestigationGroupRequest>
  Model::UpdateInvestigationGroupOutcomeCallable UpdateInvestigationGroupCallable(const UpdateInvestigationGroupRequestT& request) const {
    return SubmitCallable(&AIOpsClient::UpdateInvestigationGroup, request);
  }
 
  template <typename UpdateInvestigationGroupRequestT = Model::UpdateInvestigationGroupRequest>
  void UpdateInvestigationGroupAsync(const UpdateInvestigationGroupRequestT& request,
                                     const UpdateInvestigationGroupResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AIOpsClient::UpdateInvestigationGroup, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<AIOpsEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<AIOpsClient>;
  void init(const AIOpsClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, AIOpsError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  AIOpsClientConfiguration m_clientConfiguration;
  std::shared_ptr<AIOpsEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace AIOps
}  // namespace Aws