NovaActClient.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/nova-act/NovaActPaginationBase.h>
#include <aws/nova-act/NovaActServiceClientModel.h>
#include <aws/nova-act/NovaActWaiter.h>
#include <aws/nova-act/NovaAct_EXPORTS.h>
 
namespace Aws {
namespace NovaAct {
class AWS_NOVAACT_API NovaActClient : public Aws::Client::AWSJsonClient,
                                      public Aws::Client::ClientWithAsyncTemplateMethods<NovaActClient>,
                                      public NovaActPaginationBase<NovaActClient>,
                                      public NovaActWaiter<NovaActClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef NovaActClientConfiguration ClientConfigurationType;
  typedef NovaActEndpointProvider EndpointProviderType;
 
  NovaActClient(const Aws::NovaAct::NovaActClientConfiguration& clientConfiguration = Aws::NovaAct::NovaActClientConfiguration(),
                std::shared_ptr<NovaActEndpointProviderBase> endpointProvider = nullptr);
 
  NovaActClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<NovaActEndpointProviderBase> endpointProvider = nullptr,
                const Aws::NovaAct::NovaActClientConfiguration& clientConfiguration = Aws::NovaAct::NovaActClientConfiguration());
 
  NovaActClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                std::shared_ptr<NovaActEndpointProviderBase> endpointProvider = nullptr,
                const Aws::NovaAct::NovaActClientConfiguration& clientConfiguration = Aws::NovaAct::NovaActClientConfiguration());
 
  /* Legacy constructors due deprecation */
  NovaActClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  NovaActClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  NovaActClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~NovaActClient();
 
  virtual Model::CreateActOutcome CreateAct(const Model::CreateActRequest& request) const;
 
  template <typename CreateActRequestT = Model::CreateActRequest>
  Model::CreateActOutcomeCallable CreateActCallable(const CreateActRequestT& request) const {
    return SubmitCallable(&NovaActClient::CreateAct, request);
  }
 
  template <typename CreateActRequestT = Model::CreateActRequest>
  void CreateActAsync(const CreateActRequestT& request, const CreateActResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NovaActClient::CreateAct, request, handler, context);
  }
 
  virtual Model::CreateSessionOutcome CreateSession(const Model::CreateSessionRequest& request) const;
 
  template <typename CreateSessionRequestT = Model::CreateSessionRequest>
  Model::CreateSessionOutcomeCallable CreateSessionCallable(const CreateSessionRequestT& request) const {
    return SubmitCallable(&NovaActClient::CreateSession, request);
  }
 
  template <typename CreateSessionRequestT = Model::CreateSessionRequest>
  void CreateSessionAsync(const CreateSessionRequestT& request, const CreateSessionResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NovaActClient::CreateSession, request, handler, context);
  }
 
  virtual Model::CreateWorkflowDefinitionOutcome CreateWorkflowDefinition(const Model::CreateWorkflowDefinitionRequest& request) const;
 
  template <typename CreateWorkflowDefinitionRequestT = Model::CreateWorkflowDefinitionRequest>
  Model::CreateWorkflowDefinitionOutcomeCallable CreateWorkflowDefinitionCallable(const CreateWorkflowDefinitionRequestT& request) const {
    return SubmitCallable(&NovaActClient::CreateWorkflowDefinition, request);
  }
 
  template <typename CreateWorkflowDefinitionRequestT = Model::CreateWorkflowDefinitionRequest>
  void CreateWorkflowDefinitionAsync(const CreateWorkflowDefinitionRequestT& request,
                                     const CreateWorkflowDefinitionResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NovaActClient::CreateWorkflowDefinition, request, handler, context);
  }
 
  virtual Model::CreateWorkflowRunOutcome CreateWorkflowRun(const Model::CreateWorkflowRunRequest& request) const;
 
  template <typename CreateWorkflowRunRequestT = Model::CreateWorkflowRunRequest>
  Model::CreateWorkflowRunOutcomeCallable CreateWorkflowRunCallable(const CreateWorkflowRunRequestT& request) const {
    return SubmitCallable(&NovaActClient::CreateWorkflowRun, request);
  }
 
  template <typename CreateWorkflowRunRequestT = Model::CreateWorkflowRunRequest>
  void CreateWorkflowRunAsync(const CreateWorkflowRunRequestT& request, const CreateWorkflowRunResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NovaActClient::CreateWorkflowRun, request, handler, context);
  }
 
  virtual Model::DeleteWorkflowDefinitionOutcome DeleteWorkflowDefinition(const Model::DeleteWorkflowDefinitionRequest& request) const;
 
  template <typename DeleteWorkflowDefinitionRequestT = Model::DeleteWorkflowDefinitionRequest>
  Model::DeleteWorkflowDefinitionOutcomeCallable DeleteWorkflowDefinitionCallable(const DeleteWorkflowDefinitionRequestT& request) const {
    return SubmitCallable(&NovaActClient::DeleteWorkflowDefinition, request);
  }
 
  template <typename DeleteWorkflowDefinitionRequestT = Model::DeleteWorkflowDefinitionRequest>
  void DeleteWorkflowDefinitionAsync(const DeleteWorkflowDefinitionRequestT& request,
                                     const DeleteWorkflowDefinitionResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NovaActClient::DeleteWorkflowDefinition, request, handler, context);
  }
 
  virtual Model::DeleteWorkflowRunOutcome DeleteWorkflowRun(const Model::DeleteWorkflowRunRequest& request) const;
 
  template <typename DeleteWorkflowRunRequestT = Model::DeleteWorkflowRunRequest>
  Model::DeleteWorkflowRunOutcomeCallable DeleteWorkflowRunCallable(const DeleteWorkflowRunRequestT& request) const {
    return SubmitCallable(&NovaActClient::DeleteWorkflowRun, request);
  }
 
  template <typename DeleteWorkflowRunRequestT = Model::DeleteWorkflowRunRequest>
  void DeleteWorkflowRunAsync(const DeleteWorkflowRunRequestT& request, const DeleteWorkflowRunResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NovaActClient::DeleteWorkflowRun, request, handler, context);
  }
 
  virtual Model::GetWorkflowDefinitionOutcome GetWorkflowDefinition(const Model::GetWorkflowDefinitionRequest& request) const;
 
  template <typename GetWorkflowDefinitionRequestT = Model::GetWorkflowDefinitionRequest>
  Model::GetWorkflowDefinitionOutcomeCallable GetWorkflowDefinitionCallable(const GetWorkflowDefinitionRequestT& request) const {
    return SubmitCallable(&NovaActClient::GetWorkflowDefinition, request);
  }
 
  template <typename GetWorkflowDefinitionRequestT = Model::GetWorkflowDefinitionRequest>
  void GetWorkflowDefinitionAsync(const GetWorkflowDefinitionRequestT& request, const GetWorkflowDefinitionResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NovaActClient::GetWorkflowDefinition, request, handler, context);
  }
 
  virtual Model::GetWorkflowRunOutcome GetWorkflowRun(const Model::GetWorkflowRunRequest& request) const;
 
  template <typename GetWorkflowRunRequestT = Model::GetWorkflowRunRequest>
  Model::GetWorkflowRunOutcomeCallable GetWorkflowRunCallable(const GetWorkflowRunRequestT& request) const {
    return SubmitCallable(&NovaActClient::GetWorkflowRun, request);
  }
 
  template <typename GetWorkflowRunRequestT = Model::GetWorkflowRunRequest>
  void GetWorkflowRunAsync(const GetWorkflowRunRequestT& request, const GetWorkflowRunResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NovaActClient::GetWorkflowRun, request, handler, context);
  }
 
  virtual Model::InvokeActStepOutcome InvokeActStep(const Model::InvokeActStepRequest& request) const;
 
  template <typename InvokeActStepRequestT = Model::InvokeActStepRequest>
  Model::InvokeActStepOutcomeCallable InvokeActStepCallable(const InvokeActStepRequestT& request) const {
    return SubmitCallable(&NovaActClient::InvokeActStep, request);
  }
 
  template <typename InvokeActStepRequestT = Model::InvokeActStepRequest>
  void InvokeActStepAsync(const InvokeActStepRequestT& request, const InvokeActStepResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NovaActClient::InvokeActStep, request, handler, context);
  }
 
  virtual Model::ListActsOutcome ListActs(const Model::ListActsRequest& request) const;
 
  template <typename ListActsRequestT = Model::ListActsRequest>
  Model::ListActsOutcomeCallable ListActsCallable(const ListActsRequestT& request) const {
    return SubmitCallable(&NovaActClient::ListActs, request);
  }
 
  template <typename ListActsRequestT = Model::ListActsRequest>
  void ListActsAsync(const ListActsRequestT& request, const ListActsResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NovaActClient::ListActs, request, handler, context);
  }
 
  virtual Model::ListModelsOutcome ListModels(const Model::ListModelsRequest& request) const;
 
  template <typename ListModelsRequestT = Model::ListModelsRequest>
  Model::ListModelsOutcomeCallable ListModelsCallable(const ListModelsRequestT& request) const {
    return SubmitCallable(&NovaActClient::ListModels, request);
  }
 
  template <typename ListModelsRequestT = Model::ListModelsRequest>
  void ListModelsAsync(const ListModelsRequestT& request, const ListModelsResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NovaActClient::ListModels, request, handler, context);
  }
 
  virtual Model::ListSessionsOutcome ListSessions(const Model::ListSessionsRequest& request) const;
 
  template <typename ListSessionsRequestT = Model::ListSessionsRequest>
  Model::ListSessionsOutcomeCallable ListSessionsCallable(const ListSessionsRequestT& request) const {
    return SubmitCallable(&NovaActClient::ListSessions, request);
  }
 
  template <typename ListSessionsRequestT = Model::ListSessionsRequest>
  void ListSessionsAsync(const ListSessionsRequestT& request, const ListSessionsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NovaActClient::ListSessions, request, handler, context);
  }
 
  virtual Model::ListWorkflowDefinitionsOutcome ListWorkflowDefinitions(const Model::ListWorkflowDefinitionsRequest& request = {}) const;
 
  template <typename ListWorkflowDefinitionsRequestT = Model::ListWorkflowDefinitionsRequest>
  Model::ListWorkflowDefinitionsOutcomeCallable ListWorkflowDefinitionsCallable(const ListWorkflowDefinitionsRequestT& request = {}) const {
    return SubmitCallable(&NovaActClient::ListWorkflowDefinitions, request);
  }
 
  template <typename ListWorkflowDefinitionsRequestT = Model::ListWorkflowDefinitionsRequest>
  void ListWorkflowDefinitionsAsync(const ListWorkflowDefinitionsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const ListWorkflowDefinitionsRequestT& request = {}) const {
    return SubmitAsync(&NovaActClient::ListWorkflowDefinitions, request, handler, context);
  }
 
  virtual Model::ListWorkflowRunsOutcome ListWorkflowRuns(const Model::ListWorkflowRunsRequest& request) const;
 
  template <typename ListWorkflowRunsRequestT = Model::ListWorkflowRunsRequest>
  Model::ListWorkflowRunsOutcomeCallable ListWorkflowRunsCallable(const ListWorkflowRunsRequestT& request) const {
    return SubmitCallable(&NovaActClient::ListWorkflowRuns, request);
  }
 
  template <typename ListWorkflowRunsRequestT = Model::ListWorkflowRunsRequest>
  void ListWorkflowRunsAsync(const ListWorkflowRunsRequestT& request, const ListWorkflowRunsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NovaActClient::ListWorkflowRuns, request, handler, context);
  }
 
  virtual Model::UpdateActOutcome UpdateAct(const Model::UpdateActRequest& request) const;
 
  template <typename UpdateActRequestT = Model::UpdateActRequest>
  Model::UpdateActOutcomeCallable UpdateActCallable(const UpdateActRequestT& request) const {
    return SubmitCallable(&NovaActClient::UpdateAct, request);
  }
 
  template <typename UpdateActRequestT = Model::UpdateActRequest>
  void UpdateActAsync(const UpdateActRequestT& request, const UpdateActResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NovaActClient::UpdateAct, request, handler, context);
  }
 
  virtual Model::UpdateWorkflowRunOutcome UpdateWorkflowRun(const Model::UpdateWorkflowRunRequest& request) const;
 
  template <typename UpdateWorkflowRunRequestT = Model::UpdateWorkflowRunRequest>
  Model::UpdateWorkflowRunOutcomeCallable UpdateWorkflowRunCallable(const UpdateWorkflowRunRequestT& request) const {
    return SubmitCallable(&NovaActClient::UpdateWorkflowRun, request);
  }
 
  template <typename UpdateWorkflowRunRequestT = Model::UpdateWorkflowRunRequest>
  void UpdateWorkflowRunAsync(const UpdateWorkflowRunRequestT& request, const UpdateWorkflowRunResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&NovaActClient::UpdateWorkflowRun, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<NovaActEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<NovaActClient>;
  void init(const NovaActClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, NovaActError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  NovaActClientConfiguration m_clientConfiguration;
  std::shared_ptr<NovaActEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace NovaAct
}  // namespace Aws