ElementalInferenceClient.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/elementalinference/ElementalInferencePaginationBase.h>
#include <aws/elementalinference/ElementalInferenceServiceClientModel.h>
#include <aws/elementalinference/ElementalInferenceWaiter.h>
#include <aws/elementalinference/ElementalInference_EXPORTS.h>
 
namespace Aws {
namespace ElementalInference {
class AWS_ELEMENTALINFERENCE_API ElementalInferenceClient : public Aws::Client::AWSJsonClient,
                                                            public Aws::Client::ClientWithAsyncTemplateMethods<ElementalInferenceClient>,
                                                            public ElementalInferencePaginationBase<ElementalInferenceClient>,
                                                            public ElementalInferenceWaiter<ElementalInferenceClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef ElementalInferenceClientConfiguration ClientConfigurationType;
  typedef ElementalInferenceEndpointProvider EndpointProviderType;
 
  ElementalInferenceClient(const Aws::ElementalInference::ElementalInferenceClientConfiguration& clientConfiguration =
                               Aws::ElementalInference::ElementalInferenceClientConfiguration(),
                           std::shared_ptr<ElementalInferenceEndpointProviderBase> endpointProvider = nullptr);
 
  ElementalInferenceClient(const Aws::Auth::AWSCredentials& credentials,
                           std::shared_ptr<ElementalInferenceEndpointProviderBase> endpointProvider = nullptr,
                           const Aws::ElementalInference::ElementalInferenceClientConfiguration& clientConfiguration =
                               Aws::ElementalInference::ElementalInferenceClientConfiguration());
 
  ElementalInferenceClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                           std::shared_ptr<ElementalInferenceEndpointProviderBase> endpointProvider = nullptr,
                           const Aws::ElementalInference::ElementalInferenceClientConfiguration& clientConfiguration =
                               Aws::ElementalInference::ElementalInferenceClientConfiguration());
 
  /* Legacy constructors due deprecation */
  ElementalInferenceClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  ElementalInferenceClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  ElementalInferenceClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                           const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~ElementalInferenceClient();
 
  virtual Model::AssociateFeedOutcome AssociateFeed(const Model::AssociateFeedRequest& request) const;
 
  template <typename AssociateFeedRequestT = Model::AssociateFeedRequest>
  Model::AssociateFeedOutcomeCallable AssociateFeedCallable(const AssociateFeedRequestT& request) const {
    return SubmitCallable(&ElementalInferenceClient::AssociateFeed, request);
  }
 
  template <typename AssociateFeedRequestT = Model::AssociateFeedRequest>
  void AssociateFeedAsync(const AssociateFeedRequestT& request, const AssociateFeedResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElementalInferenceClient::AssociateFeed, request, handler, context);
  }
 
  virtual Model::CreateDictionaryOutcome CreateDictionary(const Model::CreateDictionaryRequest& request) const;
 
  template <typename CreateDictionaryRequestT = Model::CreateDictionaryRequest>
  Model::CreateDictionaryOutcomeCallable CreateDictionaryCallable(const CreateDictionaryRequestT& request) const {
    return SubmitCallable(&ElementalInferenceClient::CreateDictionary, request);
  }
 
  template <typename CreateDictionaryRequestT = Model::CreateDictionaryRequest>
  void CreateDictionaryAsync(const CreateDictionaryRequestT& request, const CreateDictionaryResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElementalInferenceClient::CreateDictionary, request, handler, context);
  }
 
  virtual Model::CreateFeedOutcome CreateFeed(const Model::CreateFeedRequest& request) const;
 
  template <typename CreateFeedRequestT = Model::CreateFeedRequest>
  Model::CreateFeedOutcomeCallable CreateFeedCallable(const CreateFeedRequestT& request) const {
    return SubmitCallable(&ElementalInferenceClient::CreateFeed, request);
  }
 
  template <typename CreateFeedRequestT = Model::CreateFeedRequest>
  void CreateFeedAsync(const CreateFeedRequestT& request, const CreateFeedResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElementalInferenceClient::CreateFeed, request, handler, context);
  }
 
  virtual Model::DeleteDictionaryOutcome DeleteDictionary(const Model::DeleteDictionaryRequest& request) const;
 
  template <typename DeleteDictionaryRequestT = Model::DeleteDictionaryRequest>
  Model::DeleteDictionaryOutcomeCallable DeleteDictionaryCallable(const DeleteDictionaryRequestT& request) const {
    return SubmitCallable(&ElementalInferenceClient::DeleteDictionary, request);
  }
 
  template <typename DeleteDictionaryRequestT = Model::DeleteDictionaryRequest>
  void DeleteDictionaryAsync(const DeleteDictionaryRequestT& request, const DeleteDictionaryResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElementalInferenceClient::DeleteDictionary, request, handler, context);
  }
 
  virtual Model::DeleteFeedOutcome DeleteFeed(const Model::DeleteFeedRequest& request) const;
 
  template <typename DeleteFeedRequestT = Model::DeleteFeedRequest>
  Model::DeleteFeedOutcomeCallable DeleteFeedCallable(const DeleteFeedRequestT& request) const {
    return SubmitCallable(&ElementalInferenceClient::DeleteFeed, request);
  }
 
  template <typename DeleteFeedRequestT = Model::DeleteFeedRequest>
  void DeleteFeedAsync(const DeleteFeedRequestT& request, const DeleteFeedResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElementalInferenceClient::DeleteFeed, request, handler, context);
  }
 
  virtual Model::DeleteFeedPolicyOutcome DeleteFeedPolicy(const Model::DeleteFeedPolicyRequest& request) const;
 
  template <typename DeleteFeedPolicyRequestT = Model::DeleteFeedPolicyRequest>
  Model::DeleteFeedPolicyOutcomeCallable DeleteFeedPolicyCallable(const DeleteFeedPolicyRequestT& request) const {
    return SubmitCallable(&ElementalInferenceClient::DeleteFeedPolicy, request);
  }
 
  template <typename DeleteFeedPolicyRequestT = Model::DeleteFeedPolicyRequest>
  void DeleteFeedPolicyAsync(const DeleteFeedPolicyRequestT& request, const DeleteFeedPolicyResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElementalInferenceClient::DeleteFeedPolicy, request, handler, context);
  }
 
  virtual Model::DisassociateFeedOutcome DisassociateFeed(const Model::DisassociateFeedRequest& request) const;
 
  template <typename DisassociateFeedRequestT = Model::DisassociateFeedRequest>
  Model::DisassociateFeedOutcomeCallable DisassociateFeedCallable(const DisassociateFeedRequestT& request) const {
    return SubmitCallable(&ElementalInferenceClient::DisassociateFeed, request);
  }
 
  template <typename DisassociateFeedRequestT = Model::DisassociateFeedRequest>
  void DisassociateFeedAsync(const DisassociateFeedRequestT& request, const DisassociateFeedResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElementalInferenceClient::DisassociateFeed, request, handler, context);
  }
 
  virtual Model::ExportDictionaryEntriesOutcome ExportDictionaryEntries(const Model::ExportDictionaryEntriesRequest& request) const;
 
  template <typename ExportDictionaryEntriesRequestT = Model::ExportDictionaryEntriesRequest>
  Model::ExportDictionaryEntriesOutcomeCallable ExportDictionaryEntriesCallable(const ExportDictionaryEntriesRequestT& request) const {
    return SubmitCallable(&ElementalInferenceClient::ExportDictionaryEntries, request);
  }
 
  template <typename ExportDictionaryEntriesRequestT = Model::ExportDictionaryEntriesRequest>
  void ExportDictionaryEntriesAsync(const ExportDictionaryEntriesRequestT& request,
                                    const ExportDictionaryEntriesResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElementalInferenceClient::ExportDictionaryEntries, request, handler, context);
  }
 
  virtual Model::GetDictionaryOutcome GetDictionary(const Model::GetDictionaryRequest& request) const;
 
  template <typename GetDictionaryRequestT = Model::GetDictionaryRequest>
  Model::GetDictionaryOutcomeCallable GetDictionaryCallable(const GetDictionaryRequestT& request) const {
    return SubmitCallable(&ElementalInferenceClient::GetDictionary, request);
  }
 
  template <typename GetDictionaryRequestT = Model::GetDictionaryRequest>
  void GetDictionaryAsync(const GetDictionaryRequestT& request, const GetDictionaryResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElementalInferenceClient::GetDictionary, request, handler, context);
  }
 
  virtual Model::GetFeedOutcome GetFeed(const Model::GetFeedRequest& request) const;
 
  template <typename GetFeedRequestT = Model::GetFeedRequest>
  Model::GetFeedOutcomeCallable GetFeedCallable(const GetFeedRequestT& request) const {
    return SubmitCallable(&ElementalInferenceClient::GetFeed, request);
  }
 
  template <typename GetFeedRequestT = Model::GetFeedRequest>
  void GetFeedAsync(const GetFeedRequestT& request, const GetFeedResponseReceivedHandler& handler,
                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElementalInferenceClient::GetFeed, request, handler, context);
  }
 
  virtual Model::GetFeedPolicyOutcome GetFeedPolicy(const Model::GetFeedPolicyRequest& request) const;
 
  template <typename GetFeedPolicyRequestT = Model::GetFeedPolicyRequest>
  Model::GetFeedPolicyOutcomeCallable GetFeedPolicyCallable(const GetFeedPolicyRequestT& request) const {
    return SubmitCallable(&ElementalInferenceClient::GetFeedPolicy, request);
  }
 
  template <typename GetFeedPolicyRequestT = Model::GetFeedPolicyRequest>
  void GetFeedPolicyAsync(const GetFeedPolicyRequestT& request, const GetFeedPolicyResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElementalInferenceClient::GetFeedPolicy, request, handler, context);
  }
 
  virtual Model::GetFixtureOutcome GetFixture(const Model::GetFixtureRequest& request) const;
 
  template <typename GetFixtureRequestT = Model::GetFixtureRequest>
  Model::GetFixtureOutcomeCallable GetFixtureCallable(const GetFixtureRequestT& request) const {
    return SubmitCallable(&ElementalInferenceClient::GetFixture, request);
  }
 
  template <typename GetFixtureRequestT = Model::GetFixtureRequest>
  void GetFixtureAsync(const GetFixtureRequestT& request, const GetFixtureResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElementalInferenceClient::GetFixture, request, handler, context);
  }
 
  virtual Model::ListDictionariesOutcome ListDictionaries(const Model::ListDictionariesRequest& request = {}) const;
 
  template <typename ListDictionariesRequestT = Model::ListDictionariesRequest>
  Model::ListDictionariesOutcomeCallable ListDictionariesCallable(const ListDictionariesRequestT& request = {}) const {
    return SubmitCallable(&ElementalInferenceClient::ListDictionaries, request);
  }
 
  template <typename ListDictionariesRequestT = Model::ListDictionariesRequest>
  void ListDictionariesAsync(const ListDictionariesResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListDictionariesRequestT& request = {}) const {
    return SubmitAsync(&ElementalInferenceClient::ListDictionaries, request, handler, context);
  }
 
  virtual Model::ListFeedsOutcome ListFeeds(const Model::ListFeedsRequest& request = {}) const;
 
  template <typename ListFeedsRequestT = Model::ListFeedsRequest>
  Model::ListFeedsOutcomeCallable ListFeedsCallable(const ListFeedsRequestT& request = {}) const {
    return SubmitCallable(&ElementalInferenceClient::ListFeeds, request);
  }
 
  template <typename ListFeedsRequestT = Model::ListFeedsRequest>
  void ListFeedsAsync(const ListFeedsResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                      const ListFeedsRequestT& request = {}) const {
    return SubmitAsync(&ElementalInferenceClient::ListFeeds, 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(&ElementalInferenceClient::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(&ElementalInferenceClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::PutFeedPolicyOutcome PutFeedPolicy(const Model::PutFeedPolicyRequest& request) const;
 
  template <typename PutFeedPolicyRequestT = Model::PutFeedPolicyRequest>
  Model::PutFeedPolicyOutcomeCallable PutFeedPolicyCallable(const PutFeedPolicyRequestT& request) const {
    return SubmitCallable(&ElementalInferenceClient::PutFeedPolicy, request);
  }
 
  template <typename PutFeedPolicyRequestT = Model::PutFeedPolicyRequest>
  void PutFeedPolicyAsync(const PutFeedPolicyRequestT& request, const PutFeedPolicyResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElementalInferenceClient::PutFeedPolicy, request, handler, context);
  }
 
  virtual Model::SearchFixturesOutcome SearchFixtures(const Model::SearchFixturesRequest& request) const;
 
  template <typename SearchFixturesRequestT = Model::SearchFixturesRequest>
  Model::SearchFixturesOutcomeCallable SearchFixturesCallable(const SearchFixturesRequestT& request) const {
    return SubmitCallable(&ElementalInferenceClient::SearchFixtures, request);
  }
 
  template <typename SearchFixturesRequestT = Model::SearchFixturesRequest>
  void SearchFixturesAsync(const SearchFixturesRequestT& request, const SearchFixturesResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElementalInferenceClient::SearchFixtures, 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(&ElementalInferenceClient::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(&ElementalInferenceClient::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(&ElementalInferenceClient::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(&ElementalInferenceClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateDictionaryOutcome UpdateDictionary(const Model::UpdateDictionaryRequest& request) const;
 
  template <typename UpdateDictionaryRequestT = Model::UpdateDictionaryRequest>
  Model::UpdateDictionaryOutcomeCallable UpdateDictionaryCallable(const UpdateDictionaryRequestT& request) const {
    return SubmitCallable(&ElementalInferenceClient::UpdateDictionary, request);
  }
 
  template <typename UpdateDictionaryRequestT = Model::UpdateDictionaryRequest>
  void UpdateDictionaryAsync(const UpdateDictionaryRequestT& request, const UpdateDictionaryResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElementalInferenceClient::UpdateDictionary, request, handler, context);
  }
 
  virtual Model::UpdateFeedOutcome UpdateFeed(const Model::UpdateFeedRequest& request) const;
 
  template <typename UpdateFeedRequestT = Model::UpdateFeedRequest>
  Model::UpdateFeedOutcomeCallable UpdateFeedCallable(const UpdateFeedRequestT& request) const {
    return SubmitCallable(&ElementalInferenceClient::UpdateFeed, request);
  }
 
  template <typename UpdateFeedRequestT = Model::UpdateFeedRequest>
  void UpdateFeedAsync(const UpdateFeedRequestT& request, const UpdateFeedResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ElementalInferenceClient::UpdateFeed, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<ElementalInferenceEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<ElementalInferenceClient>;
  void init(const ElementalInferenceClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, ElementalInferenceError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  ElementalInferenceClientConfiguration m_clientConfiguration;
  std::shared_ptr<ElementalInferenceEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace ElementalInference
}  // namespace Aws