LambdaWebClient.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/lambda-web/LambdaWebPaginationBase.h>
#include <aws/lambda-web/LambdaWebServiceClientModel.h>
#include <aws/lambda-web/LambdaWebWaiter.h>
#include <aws/lambda-web/LambdaWeb_EXPORTS.h>
 
namespace Aws {
namespace LambdaWeb {
class AWS_LAMBDAWEB_API LambdaWebClient : public Aws::Client::AWSJsonClient,
                                          public Aws::Client::ClientWithAsyncTemplateMethods<LambdaWebClient>,
                                          public LambdaWebPaginationBase<LambdaWebClient>,
                                          public LambdaWebWaiter<LambdaWebClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef LambdaWebClientConfiguration ClientConfigurationType;
  typedef LambdaWebEndpointProvider EndpointProviderType;
 
  LambdaWebClient(const Aws::LambdaWeb::LambdaWebClientConfiguration& clientConfiguration = Aws::LambdaWeb::LambdaWebClientConfiguration(),
                  std::shared_ptr<LambdaWebEndpointProviderBase> endpointProvider = nullptr);
 
  LambdaWebClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<LambdaWebEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::LambdaWeb::LambdaWebClientConfiguration& clientConfiguration = Aws::LambdaWeb::LambdaWebClientConfiguration());
 
  LambdaWebClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  std::shared_ptr<LambdaWebEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::LambdaWeb::LambdaWebClientConfiguration& clientConfiguration = Aws::LambdaWeb::LambdaWebClientConfiguration());
 
  /* Legacy constructors due deprecation */
  LambdaWebClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  LambdaWebClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  LambdaWebClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~LambdaWebClient();
 
  virtual Model::CreateWebFunctionOutcome CreateWebFunction(const Model::CreateWebFunctionRequest& request) const;
 
  template <typename CreateWebFunctionRequestT = Model::CreateWebFunctionRequest>
  Model::CreateWebFunctionOutcomeCallable CreateWebFunctionCallable(const CreateWebFunctionRequestT& request) const {
    return SubmitCallable(&LambdaWebClient::CreateWebFunction, request);
  }
 
  template <typename CreateWebFunctionRequestT = Model::CreateWebFunctionRequest>
  void CreateWebFunctionAsync(const CreateWebFunctionRequestT& request, const CreateWebFunctionResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaWebClient::CreateWebFunction, request, handler, context);
  }
 
  virtual Model::CreateWebFunctionEndpointOutcome CreateWebFunctionEndpoint(const Model::CreateWebFunctionEndpointRequest& request) const;
 
  template <typename CreateWebFunctionEndpointRequestT = Model::CreateWebFunctionEndpointRequest>
  Model::CreateWebFunctionEndpointOutcomeCallable CreateWebFunctionEndpointCallable(
      const CreateWebFunctionEndpointRequestT& request) const {
    return SubmitCallable(&LambdaWebClient::CreateWebFunctionEndpoint, request);
  }
 
  template <typename CreateWebFunctionEndpointRequestT = Model::CreateWebFunctionEndpointRequest>
  void CreateWebFunctionEndpointAsync(const CreateWebFunctionEndpointRequestT& request,
                                      const CreateWebFunctionEndpointResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaWebClient::CreateWebFunctionEndpoint, request, handler, context);
  }
 
  virtual Model::CreateWebFunctionRevisionOutcome CreateWebFunctionRevision(const Model::CreateWebFunctionRevisionRequest& request) const;
 
  template <typename CreateWebFunctionRevisionRequestT = Model::CreateWebFunctionRevisionRequest>
  Model::CreateWebFunctionRevisionOutcomeCallable CreateWebFunctionRevisionCallable(
      const CreateWebFunctionRevisionRequestT& request) const {
    return SubmitCallable(&LambdaWebClient::CreateWebFunctionRevision, request);
  }
 
  template <typename CreateWebFunctionRevisionRequestT = Model::CreateWebFunctionRevisionRequest>
  void CreateWebFunctionRevisionAsync(const CreateWebFunctionRevisionRequestT& request,
                                      const CreateWebFunctionRevisionResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaWebClient::CreateWebFunctionRevision, request, handler, context);
  }
 
  virtual Model::DeleteResourcePolicyOutcome DeleteResourcePolicy(const Model::DeleteResourcePolicyRequest& request) const;
 
  template <typename DeleteResourcePolicyRequestT = Model::DeleteResourcePolicyRequest>
  Model::DeleteResourcePolicyOutcomeCallable DeleteResourcePolicyCallable(const DeleteResourcePolicyRequestT& request) const {
    return SubmitCallable(&LambdaWebClient::DeleteResourcePolicy, request);
  }
 
  template <typename DeleteResourcePolicyRequestT = Model::DeleteResourcePolicyRequest>
  void DeleteResourcePolicyAsync(const DeleteResourcePolicyRequestT& request, const DeleteResourcePolicyResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaWebClient::DeleteResourcePolicy, request, handler, context);
  }
 
  virtual Model::DeleteWebFunctionOutcome DeleteWebFunction(const Model::DeleteWebFunctionRequest& request) const;
 
  template <typename DeleteWebFunctionRequestT = Model::DeleteWebFunctionRequest>
  Model::DeleteWebFunctionOutcomeCallable DeleteWebFunctionCallable(const DeleteWebFunctionRequestT& request) const {
    return SubmitCallable(&LambdaWebClient::DeleteWebFunction, request);
  }
 
  template <typename DeleteWebFunctionRequestT = Model::DeleteWebFunctionRequest>
  void DeleteWebFunctionAsync(const DeleteWebFunctionRequestT& request, const DeleteWebFunctionResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaWebClient::DeleteWebFunction, request, handler, context);
  }
 
  virtual Model::DeleteWebFunctionEndpointOutcome DeleteWebFunctionEndpoint(const Model::DeleteWebFunctionEndpointRequest& request) const;
 
  template <typename DeleteWebFunctionEndpointRequestT = Model::DeleteWebFunctionEndpointRequest>
  Model::DeleteWebFunctionEndpointOutcomeCallable DeleteWebFunctionEndpointCallable(
      const DeleteWebFunctionEndpointRequestT& request) const {
    return SubmitCallable(&LambdaWebClient::DeleteWebFunctionEndpoint, request);
  }
 
  template <typename DeleteWebFunctionEndpointRequestT = Model::DeleteWebFunctionEndpointRequest>
  void DeleteWebFunctionEndpointAsync(const DeleteWebFunctionEndpointRequestT& request,
                                      const DeleteWebFunctionEndpointResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaWebClient::DeleteWebFunctionEndpoint, request, handler, context);
  }
 
  virtual Model::DeleteWebFunctionRevisionOutcome DeleteWebFunctionRevision(const Model::DeleteWebFunctionRevisionRequest& request) const;
 
  template <typename DeleteWebFunctionRevisionRequestT = Model::DeleteWebFunctionRevisionRequest>
  Model::DeleteWebFunctionRevisionOutcomeCallable DeleteWebFunctionRevisionCallable(
      const DeleteWebFunctionRevisionRequestT& request) const {
    return SubmitCallable(&LambdaWebClient::DeleteWebFunctionRevision, request);
  }
 
  template <typename DeleteWebFunctionRevisionRequestT = Model::DeleteWebFunctionRevisionRequest>
  void DeleteWebFunctionRevisionAsync(const DeleteWebFunctionRevisionRequestT& request,
                                      const DeleteWebFunctionRevisionResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaWebClient::DeleteWebFunctionRevision, request, handler, context);
  }
 
  virtual Model::GetResourcePolicyOutcome GetResourcePolicy(const Model::GetResourcePolicyRequest& request) const;
 
  template <typename GetResourcePolicyRequestT = Model::GetResourcePolicyRequest>
  Model::GetResourcePolicyOutcomeCallable GetResourcePolicyCallable(const GetResourcePolicyRequestT& request) const {
    return SubmitCallable(&LambdaWebClient::GetResourcePolicy, request);
  }
 
  template <typename GetResourcePolicyRequestT = Model::GetResourcePolicyRequest>
  void GetResourcePolicyAsync(const GetResourcePolicyRequestT& request, const GetResourcePolicyResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaWebClient::GetResourcePolicy, request, handler, context);
  }
 
  virtual Model::GetWebAccountSettingsOutcome GetWebAccountSettings(const Model::GetWebAccountSettingsRequest& request = {}) const;
 
  template <typename GetWebAccountSettingsRequestT = Model::GetWebAccountSettingsRequest>
  Model::GetWebAccountSettingsOutcomeCallable GetWebAccountSettingsCallable(const GetWebAccountSettingsRequestT& request = {}) const {
    return SubmitCallable(&LambdaWebClient::GetWebAccountSettings, request);
  }
 
  template <typename GetWebAccountSettingsRequestT = Model::GetWebAccountSettingsRequest>
  void GetWebAccountSettingsAsync(const GetWebAccountSettingsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                  const GetWebAccountSettingsRequestT& request = {}) const {
    return SubmitAsync(&LambdaWebClient::GetWebAccountSettings, request, handler, context);
  }
 
  virtual Model::GetWebFunctionOutcome GetWebFunction(const Model::GetWebFunctionRequest& request) const;
 
  template <typename GetWebFunctionRequestT = Model::GetWebFunctionRequest>
  Model::GetWebFunctionOutcomeCallable GetWebFunctionCallable(const GetWebFunctionRequestT& request) const {
    return SubmitCallable(&LambdaWebClient::GetWebFunction, request);
  }
 
  template <typename GetWebFunctionRequestT = Model::GetWebFunctionRequest>
  void GetWebFunctionAsync(const GetWebFunctionRequestT& request, const GetWebFunctionResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaWebClient::GetWebFunction, request, handler, context);
  }
 
  virtual Model::GetWebFunctionEndpointOutcome GetWebFunctionEndpoint(const Model::GetWebFunctionEndpointRequest& request) const;
 
  template <typename GetWebFunctionEndpointRequestT = Model::GetWebFunctionEndpointRequest>
  Model::GetWebFunctionEndpointOutcomeCallable GetWebFunctionEndpointCallable(const GetWebFunctionEndpointRequestT& request) const {
    return SubmitCallable(&LambdaWebClient::GetWebFunctionEndpoint, request);
  }
 
  template <typename GetWebFunctionEndpointRequestT = Model::GetWebFunctionEndpointRequest>
  void GetWebFunctionEndpointAsync(const GetWebFunctionEndpointRequestT& request,
                                   const GetWebFunctionEndpointResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaWebClient::GetWebFunctionEndpoint, request, handler, context);
  }
 
  virtual Model::GetWebFunctionRevisionOutcome GetWebFunctionRevision(const Model::GetWebFunctionRevisionRequest& request) const;
 
  template <typename GetWebFunctionRevisionRequestT = Model::GetWebFunctionRevisionRequest>
  Model::GetWebFunctionRevisionOutcomeCallable GetWebFunctionRevisionCallable(const GetWebFunctionRevisionRequestT& request) const {
    return SubmitCallable(&LambdaWebClient::GetWebFunctionRevision, request);
  }
 
  template <typename GetWebFunctionRevisionRequestT = Model::GetWebFunctionRevisionRequest>
  void GetWebFunctionRevisionAsync(const GetWebFunctionRevisionRequestT& request,
                                   const GetWebFunctionRevisionResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaWebClient::GetWebFunctionRevision, request, handler, context);
  }
 
  virtual Model::ListTagsOutcome ListTags(const Model::ListTagsRequest& request) const;
 
  template <typename ListTagsRequestT = Model::ListTagsRequest>
  Model::ListTagsOutcomeCallable ListTagsCallable(const ListTagsRequestT& request) const {
    return SubmitCallable(&LambdaWebClient::ListTags, request);
  }
 
  template <typename ListTagsRequestT = Model::ListTagsRequest>
  void ListTagsAsync(const ListTagsRequestT& request, const ListTagsResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaWebClient::ListTags, request, handler, context);
  }
 
  virtual Model::ListWebFunctionEndpointsOutcome ListWebFunctionEndpoints(const Model::ListWebFunctionEndpointsRequest& request) const;
 
  template <typename ListWebFunctionEndpointsRequestT = Model::ListWebFunctionEndpointsRequest>
  Model::ListWebFunctionEndpointsOutcomeCallable ListWebFunctionEndpointsCallable(const ListWebFunctionEndpointsRequestT& request) const {
    return SubmitCallable(&LambdaWebClient::ListWebFunctionEndpoints, request);
  }
 
  template <typename ListWebFunctionEndpointsRequestT = Model::ListWebFunctionEndpointsRequest>
  void ListWebFunctionEndpointsAsync(const ListWebFunctionEndpointsRequestT& request,
                                     const ListWebFunctionEndpointsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaWebClient::ListWebFunctionEndpoints, request, handler, context);
  }
 
  virtual Model::ListWebFunctionRevisionsOutcome ListWebFunctionRevisions(const Model::ListWebFunctionRevisionsRequest& request) const;
 
  template <typename ListWebFunctionRevisionsRequestT = Model::ListWebFunctionRevisionsRequest>
  Model::ListWebFunctionRevisionsOutcomeCallable ListWebFunctionRevisionsCallable(const ListWebFunctionRevisionsRequestT& request) const {
    return SubmitCallable(&LambdaWebClient::ListWebFunctionRevisions, request);
  }
 
  template <typename ListWebFunctionRevisionsRequestT = Model::ListWebFunctionRevisionsRequest>
  void ListWebFunctionRevisionsAsync(const ListWebFunctionRevisionsRequestT& request,
                                     const ListWebFunctionRevisionsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaWebClient::ListWebFunctionRevisions, request, handler, context);
  }
 
  virtual Model::ListWebFunctionsOutcome ListWebFunctions(const Model::ListWebFunctionsRequest& request = {}) const;
 
  template <typename ListWebFunctionsRequestT = Model::ListWebFunctionsRequest>
  Model::ListWebFunctionsOutcomeCallable ListWebFunctionsCallable(const ListWebFunctionsRequestT& request = {}) const {
    return SubmitCallable(&LambdaWebClient::ListWebFunctions, request);
  }
 
  template <typename ListWebFunctionsRequestT = Model::ListWebFunctionsRequest>
  void ListWebFunctionsAsync(const ListWebFunctionsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListWebFunctionsRequestT& request = {}) const {
    return SubmitAsync(&LambdaWebClient::ListWebFunctions, request, handler, context);
  }
 
  virtual Model::PutResourcePolicyOutcome PutResourcePolicy(const Model::PutResourcePolicyRequest& request) const;
 
  template <typename PutResourcePolicyRequestT = Model::PutResourcePolicyRequest>
  Model::PutResourcePolicyOutcomeCallable PutResourcePolicyCallable(const PutResourcePolicyRequestT& request) const {
    return SubmitCallable(&LambdaWebClient::PutResourcePolicy, request);
  }
 
  template <typename PutResourcePolicyRequestT = Model::PutResourcePolicyRequest>
  void PutResourcePolicyAsync(const PutResourcePolicyRequestT& request, const PutResourcePolicyResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaWebClient::PutResourcePolicy, 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(&LambdaWebClient::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(&LambdaWebClient::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(&LambdaWebClient::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(&LambdaWebClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateWebFunctionEndpointOutcome UpdateWebFunctionEndpoint(const Model::UpdateWebFunctionEndpointRequest& request) const;
 
  template <typename UpdateWebFunctionEndpointRequestT = Model::UpdateWebFunctionEndpointRequest>
  Model::UpdateWebFunctionEndpointOutcomeCallable UpdateWebFunctionEndpointCallable(
      const UpdateWebFunctionEndpointRequestT& request) const {
    return SubmitCallable(&LambdaWebClient::UpdateWebFunctionEndpoint, request);
  }
 
  template <typename UpdateWebFunctionEndpointRequestT = Model::UpdateWebFunctionEndpointRequest>
  void UpdateWebFunctionEndpointAsync(const UpdateWebFunctionEndpointRequestT& request,
                                      const UpdateWebFunctionEndpointResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaWebClient::UpdateWebFunctionEndpoint, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<LambdaWebEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<LambdaWebClient>;
  void init(const LambdaWebClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, LambdaWebError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  LambdaWebClientConfiguration m_clientConfiguration;
  std::shared_ptr<LambdaWebEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace LambdaWeb
}  // namespace Aws