LambdaClient.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/LambdaPaginationBase.h>
#include <aws/lambda/LambdaServiceClientModel.h>
#include <aws/lambda/LambdaWaiter.h>
#include <aws/lambda/Lambda_EXPORTS.h>
 
namespace Aws {
namespace Lambda {
class AWS_LAMBDA_API LambdaClient : public Aws::Client::AWSJsonClient,
                                    public Aws::Client::ClientWithAsyncTemplateMethods<LambdaClient>,
                                    public LambdaPaginationBase<LambdaClient>,
                                    public LambdaWaiter<LambdaClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef LambdaClientConfiguration ClientConfigurationType;
  typedef LambdaEndpointProvider EndpointProviderType;
 
  LambdaClient(const Aws::Lambda::LambdaClientConfiguration& clientConfiguration = Aws::Lambda::LambdaClientConfiguration(),
               std::shared_ptr<LambdaEndpointProviderBase> endpointProvider = nullptr);
 
  LambdaClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<LambdaEndpointProviderBase> endpointProvider = nullptr,
               const Aws::Lambda::LambdaClientConfiguration& clientConfiguration = Aws::Lambda::LambdaClientConfiguration());
 
  LambdaClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
               std::shared_ptr<LambdaEndpointProviderBase> endpointProvider = nullptr,
               const Aws::Lambda::LambdaClientConfiguration& clientConfiguration = Aws::Lambda::LambdaClientConfiguration());
 
  /* Legacy constructors due deprecation */
  LambdaClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  LambdaClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  LambdaClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
               const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~LambdaClient();
 
  virtual Model::AddLayerVersionPermissionOutcome AddLayerVersionPermission(const Model::AddLayerVersionPermissionRequest& request) const;
 
  template <typename AddLayerVersionPermissionRequestT = Model::AddLayerVersionPermissionRequest>
  Model::AddLayerVersionPermissionOutcomeCallable AddLayerVersionPermissionCallable(
      const AddLayerVersionPermissionRequestT& request) const {
    return SubmitCallable(&LambdaClient::AddLayerVersionPermission, request);
  }
 
  template <typename AddLayerVersionPermissionRequestT = Model::AddLayerVersionPermissionRequest>
  void AddLayerVersionPermissionAsync(const AddLayerVersionPermissionRequestT& request,
                                      const AddLayerVersionPermissionResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::AddLayerVersionPermission, request, handler, context);
  }
 
  virtual Model::AddPermissionOutcome AddPermission(const Model::AddPermissionRequest& request) const;
 
  template <typename AddPermissionRequestT = Model::AddPermissionRequest>
  Model::AddPermissionOutcomeCallable AddPermissionCallable(const AddPermissionRequestT& request) const {
    return SubmitCallable(&LambdaClient::AddPermission, request);
  }
 
  template <typename AddPermissionRequestT = Model::AddPermissionRequest>
  void AddPermissionAsync(const AddPermissionRequestT& request, const AddPermissionResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::AddPermission, request, handler, context);
  }
 
  virtual Model::CheckpointDurableExecutionOutcome CheckpointDurableExecution(
      const Model::CheckpointDurableExecutionRequest& request) const;
 
  template <typename CheckpointDurableExecutionRequestT = Model::CheckpointDurableExecutionRequest>
  Model::CheckpointDurableExecutionOutcomeCallable CheckpointDurableExecutionCallable(
      const CheckpointDurableExecutionRequestT& request) const {
    return SubmitCallable(&LambdaClient::CheckpointDurableExecution, request);
  }
 
  template <typename CheckpointDurableExecutionRequestT = Model::CheckpointDurableExecutionRequest>
  void CheckpointDurableExecutionAsync(const CheckpointDurableExecutionRequestT& request,
                                       const CheckpointDurableExecutionResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::CheckpointDurableExecution, request, handler, context);
  }
 
  virtual Model::CreateAliasOutcome CreateAlias(const Model::CreateAliasRequest& request) const;
 
  template <typename CreateAliasRequestT = Model::CreateAliasRequest>
  Model::CreateAliasOutcomeCallable CreateAliasCallable(const CreateAliasRequestT& request) const {
    return SubmitCallable(&LambdaClient::CreateAlias, request);
  }
 
  template <typename CreateAliasRequestT = Model::CreateAliasRequest>
  void CreateAliasAsync(const CreateAliasRequestT& request, const CreateAliasResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::CreateAlias, request, handler, context);
  }
 
  virtual Model::CreateCapacityProviderOutcome CreateCapacityProvider(const Model::CreateCapacityProviderRequest& request) const;
 
  template <typename CreateCapacityProviderRequestT = Model::CreateCapacityProviderRequest>
  Model::CreateCapacityProviderOutcomeCallable CreateCapacityProviderCallable(const CreateCapacityProviderRequestT& request) const {
    return SubmitCallable(&LambdaClient::CreateCapacityProvider, request);
  }
 
  template <typename CreateCapacityProviderRequestT = Model::CreateCapacityProviderRequest>
  void CreateCapacityProviderAsync(const CreateCapacityProviderRequestT& request,
                                   const CreateCapacityProviderResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::CreateCapacityProvider, request, handler, context);
  }
 
  virtual Model::CreateCodeSigningConfigOutcome CreateCodeSigningConfig(const Model::CreateCodeSigningConfigRequest& request) const;
 
  template <typename CreateCodeSigningConfigRequestT = Model::CreateCodeSigningConfigRequest>
  Model::CreateCodeSigningConfigOutcomeCallable CreateCodeSigningConfigCallable(const CreateCodeSigningConfigRequestT& request) const {
    return SubmitCallable(&LambdaClient::CreateCodeSigningConfig, request);
  }
 
  template <typename CreateCodeSigningConfigRequestT = Model::CreateCodeSigningConfigRequest>
  void CreateCodeSigningConfigAsync(const CreateCodeSigningConfigRequestT& request,
                                    const CreateCodeSigningConfigResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::CreateCodeSigningConfig, request, handler, context);
  }
 
  virtual Model::CreateEventSourceMappingOutcome CreateEventSourceMapping(const Model::CreateEventSourceMappingRequest& request) const;
 
  template <typename CreateEventSourceMappingRequestT = Model::CreateEventSourceMappingRequest>
  Model::CreateEventSourceMappingOutcomeCallable CreateEventSourceMappingCallable(const CreateEventSourceMappingRequestT& request) const {
    return SubmitCallable(&LambdaClient::CreateEventSourceMapping, request);
  }
 
  template <typename CreateEventSourceMappingRequestT = Model::CreateEventSourceMappingRequest>
  void CreateEventSourceMappingAsync(const CreateEventSourceMappingRequestT& request,
                                     const CreateEventSourceMappingResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::CreateEventSourceMapping, request, handler, context);
  }
 
  virtual Model::CreateFunctionOutcome CreateFunction(const Model::CreateFunctionRequest& request) const;
 
  template <typename CreateFunctionRequestT = Model::CreateFunctionRequest>
  Model::CreateFunctionOutcomeCallable CreateFunctionCallable(const CreateFunctionRequestT& request) const {
    return SubmitCallable(&LambdaClient::CreateFunction, request);
  }
 
  template <typename CreateFunctionRequestT = Model::CreateFunctionRequest>
  void CreateFunctionAsync(const CreateFunctionRequestT& request, const CreateFunctionResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::CreateFunction, request, handler, context);
  }
 
  virtual Model::CreateFunctionUrlConfigOutcome CreateFunctionUrlConfig(const Model::CreateFunctionUrlConfigRequest& request) const;
 
  template <typename CreateFunctionUrlConfigRequestT = Model::CreateFunctionUrlConfigRequest>
  Model::CreateFunctionUrlConfigOutcomeCallable CreateFunctionUrlConfigCallable(const CreateFunctionUrlConfigRequestT& request) const {
    return SubmitCallable(&LambdaClient::CreateFunctionUrlConfig, request);
  }
 
  template <typename CreateFunctionUrlConfigRequestT = Model::CreateFunctionUrlConfigRequest>
  void CreateFunctionUrlConfigAsync(const CreateFunctionUrlConfigRequestT& request,
                                    const CreateFunctionUrlConfigResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::CreateFunctionUrlConfig, request, handler, context);
  }
 
  virtual Model::DeleteAliasOutcome DeleteAlias(const Model::DeleteAliasRequest& request) const;
 
  template <typename DeleteAliasRequestT = Model::DeleteAliasRequest>
  Model::DeleteAliasOutcomeCallable DeleteAliasCallable(const DeleteAliasRequestT& request) const {
    return SubmitCallable(&LambdaClient::DeleteAlias, request);
  }
 
  template <typename DeleteAliasRequestT = Model::DeleteAliasRequest>
  void DeleteAliasAsync(const DeleteAliasRequestT& request, const DeleteAliasResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::DeleteAlias, request, handler, context);
  }
 
  virtual Model::DeleteCapacityProviderOutcome DeleteCapacityProvider(const Model::DeleteCapacityProviderRequest& request) const;
 
  template <typename DeleteCapacityProviderRequestT = Model::DeleteCapacityProviderRequest>
  Model::DeleteCapacityProviderOutcomeCallable DeleteCapacityProviderCallable(const DeleteCapacityProviderRequestT& request) const {
    return SubmitCallable(&LambdaClient::DeleteCapacityProvider, request);
  }
 
  template <typename DeleteCapacityProviderRequestT = Model::DeleteCapacityProviderRequest>
  void DeleteCapacityProviderAsync(const DeleteCapacityProviderRequestT& request,
                                   const DeleteCapacityProviderResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::DeleteCapacityProvider, request, handler, context);
  }
 
  virtual Model::DeleteCodeSigningConfigOutcome DeleteCodeSigningConfig(const Model::DeleteCodeSigningConfigRequest& request) const;
 
  template <typename DeleteCodeSigningConfigRequestT = Model::DeleteCodeSigningConfigRequest>
  Model::DeleteCodeSigningConfigOutcomeCallable DeleteCodeSigningConfigCallable(const DeleteCodeSigningConfigRequestT& request) const {
    return SubmitCallable(&LambdaClient::DeleteCodeSigningConfig, request);
  }
 
  template <typename DeleteCodeSigningConfigRequestT = Model::DeleteCodeSigningConfigRequest>
  void DeleteCodeSigningConfigAsync(const DeleteCodeSigningConfigRequestT& request,
                                    const DeleteCodeSigningConfigResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::DeleteCodeSigningConfig, request, handler, context);
  }
 
  virtual Model::DeleteEventSourceMappingOutcome DeleteEventSourceMapping(const Model::DeleteEventSourceMappingRequest& request) const;
 
  template <typename DeleteEventSourceMappingRequestT = Model::DeleteEventSourceMappingRequest>
  Model::DeleteEventSourceMappingOutcomeCallable DeleteEventSourceMappingCallable(const DeleteEventSourceMappingRequestT& request) const {
    return SubmitCallable(&LambdaClient::DeleteEventSourceMapping, request);
  }
 
  template <typename DeleteEventSourceMappingRequestT = Model::DeleteEventSourceMappingRequest>
  void DeleteEventSourceMappingAsync(const DeleteEventSourceMappingRequestT& request,
                                     const DeleteEventSourceMappingResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::DeleteEventSourceMapping, request, handler, context);
  }
 
  virtual Model::DeleteFunctionOutcome DeleteFunction(const Model::DeleteFunctionRequest& request) const;
 
  template <typename DeleteFunctionRequestT = Model::DeleteFunctionRequest>
  Model::DeleteFunctionOutcomeCallable DeleteFunctionCallable(const DeleteFunctionRequestT& request) const {
    return SubmitCallable(&LambdaClient::DeleteFunction, request);
  }
 
  template <typename DeleteFunctionRequestT = Model::DeleteFunctionRequest>
  void DeleteFunctionAsync(const DeleteFunctionRequestT& request, const DeleteFunctionResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::DeleteFunction, request, handler, context);
  }
 
  virtual Model::DeleteFunctionCodeSigningConfigOutcome DeleteFunctionCodeSigningConfig(
      const Model::DeleteFunctionCodeSigningConfigRequest& request) const;
 
  template <typename DeleteFunctionCodeSigningConfigRequestT = Model::DeleteFunctionCodeSigningConfigRequest>
  Model::DeleteFunctionCodeSigningConfigOutcomeCallable DeleteFunctionCodeSigningConfigCallable(
      const DeleteFunctionCodeSigningConfigRequestT& request) const {
    return SubmitCallable(&LambdaClient::DeleteFunctionCodeSigningConfig, request);
  }
 
  template <typename DeleteFunctionCodeSigningConfigRequestT = Model::DeleteFunctionCodeSigningConfigRequest>
  void DeleteFunctionCodeSigningConfigAsync(const DeleteFunctionCodeSigningConfigRequestT& request,
                                            const DeleteFunctionCodeSigningConfigResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::DeleteFunctionCodeSigningConfig, request, handler, context);
  }
 
  virtual Model::DeleteFunctionConcurrencyOutcome DeleteFunctionConcurrency(const Model::DeleteFunctionConcurrencyRequest& request) const;
 
  template <typename DeleteFunctionConcurrencyRequestT = Model::DeleteFunctionConcurrencyRequest>
  Model::DeleteFunctionConcurrencyOutcomeCallable DeleteFunctionConcurrencyCallable(
      const DeleteFunctionConcurrencyRequestT& request) const {
    return SubmitCallable(&LambdaClient::DeleteFunctionConcurrency, request);
  }
 
  template <typename DeleteFunctionConcurrencyRequestT = Model::DeleteFunctionConcurrencyRequest>
  void DeleteFunctionConcurrencyAsync(const DeleteFunctionConcurrencyRequestT& request,
                                      const DeleteFunctionConcurrencyResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::DeleteFunctionConcurrency, request, handler, context);
  }
 
  virtual Model::DeleteFunctionEventInvokeConfigOutcome DeleteFunctionEventInvokeConfig(
      const Model::DeleteFunctionEventInvokeConfigRequest& request) const;
 
  template <typename DeleteFunctionEventInvokeConfigRequestT = Model::DeleteFunctionEventInvokeConfigRequest>
  Model::DeleteFunctionEventInvokeConfigOutcomeCallable DeleteFunctionEventInvokeConfigCallable(
      const DeleteFunctionEventInvokeConfigRequestT& request) const {
    return SubmitCallable(&LambdaClient::DeleteFunctionEventInvokeConfig, request);
  }
 
  template <typename DeleteFunctionEventInvokeConfigRequestT = Model::DeleteFunctionEventInvokeConfigRequest>
  void DeleteFunctionEventInvokeConfigAsync(const DeleteFunctionEventInvokeConfigRequestT& request,
                                            const DeleteFunctionEventInvokeConfigResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::DeleteFunctionEventInvokeConfig, request, handler, context);
  }
 
  virtual Model::DeleteFunctionUrlConfigOutcome DeleteFunctionUrlConfig(const Model::DeleteFunctionUrlConfigRequest& request) const;
 
  template <typename DeleteFunctionUrlConfigRequestT = Model::DeleteFunctionUrlConfigRequest>
  Model::DeleteFunctionUrlConfigOutcomeCallable DeleteFunctionUrlConfigCallable(const DeleteFunctionUrlConfigRequestT& request) const {
    return SubmitCallable(&LambdaClient::DeleteFunctionUrlConfig, request);
  }
 
  template <typename DeleteFunctionUrlConfigRequestT = Model::DeleteFunctionUrlConfigRequest>
  void DeleteFunctionUrlConfigAsync(const DeleteFunctionUrlConfigRequestT& request,
                                    const DeleteFunctionUrlConfigResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::DeleteFunctionUrlConfig, request, handler, context);
  }
 
  virtual Model::DeleteLayerVersionOutcome DeleteLayerVersion(const Model::DeleteLayerVersionRequest& request) const;
 
  template <typename DeleteLayerVersionRequestT = Model::DeleteLayerVersionRequest>
  Model::DeleteLayerVersionOutcomeCallable DeleteLayerVersionCallable(const DeleteLayerVersionRequestT& request) const {
    return SubmitCallable(&LambdaClient::DeleteLayerVersion, request);
  }
 
  template <typename DeleteLayerVersionRequestT = Model::DeleteLayerVersionRequest>
  void DeleteLayerVersionAsync(const DeleteLayerVersionRequestT& request, const DeleteLayerVersionResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::DeleteLayerVersion, request, handler, context);
  }
 
  virtual Model::DeleteProvisionedConcurrencyConfigOutcome DeleteProvisionedConcurrencyConfig(
      const Model::DeleteProvisionedConcurrencyConfigRequest& request) const;
 
  template <typename DeleteProvisionedConcurrencyConfigRequestT = Model::DeleteProvisionedConcurrencyConfigRequest>
  Model::DeleteProvisionedConcurrencyConfigOutcomeCallable DeleteProvisionedConcurrencyConfigCallable(
      const DeleteProvisionedConcurrencyConfigRequestT& request) const {
    return SubmitCallable(&LambdaClient::DeleteProvisionedConcurrencyConfig, request);
  }
 
  template <typename DeleteProvisionedConcurrencyConfigRequestT = Model::DeleteProvisionedConcurrencyConfigRequest>
  void DeleteProvisionedConcurrencyConfigAsync(const DeleteProvisionedConcurrencyConfigRequestT& request,
                                               const DeleteProvisionedConcurrencyConfigResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::DeleteProvisionedConcurrencyConfig, request, handler, context);
  }
 
  virtual Model::GetAccountSettingsOutcome GetAccountSettings(const Model::GetAccountSettingsRequest& request = {}) const;
 
  template <typename GetAccountSettingsRequestT = Model::GetAccountSettingsRequest>
  Model::GetAccountSettingsOutcomeCallable GetAccountSettingsCallable(const GetAccountSettingsRequestT& request = {}) const {
    return SubmitCallable(&LambdaClient::GetAccountSettings, request);
  }
 
  template <typename GetAccountSettingsRequestT = Model::GetAccountSettingsRequest>
  void GetAccountSettingsAsync(const GetAccountSettingsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const GetAccountSettingsRequestT& request = {}) const {
    return SubmitAsync(&LambdaClient::GetAccountSettings, request, handler, context);
  }
 
  virtual Model::GetAliasOutcome GetAlias(const Model::GetAliasRequest& request) const;
 
  template <typename GetAliasRequestT = Model::GetAliasRequest>
  Model::GetAliasOutcomeCallable GetAliasCallable(const GetAliasRequestT& request) const {
    return SubmitCallable(&LambdaClient::GetAlias, request);
  }
 
  template <typename GetAliasRequestT = Model::GetAliasRequest>
  void GetAliasAsync(const GetAliasRequestT& request, const GetAliasResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::GetAlias, request, handler, context);
  }
 
  virtual Model::GetCapacityProviderOutcome GetCapacityProvider(const Model::GetCapacityProviderRequest& request) const;
 
  template <typename GetCapacityProviderRequestT = Model::GetCapacityProviderRequest>
  Model::GetCapacityProviderOutcomeCallable GetCapacityProviderCallable(const GetCapacityProviderRequestT& request) const {
    return SubmitCallable(&LambdaClient::GetCapacityProvider, request);
  }
 
  template <typename GetCapacityProviderRequestT = Model::GetCapacityProviderRequest>
  void GetCapacityProviderAsync(const GetCapacityProviderRequestT& request, const GetCapacityProviderResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::GetCapacityProvider, request, handler, context);
  }
 
  virtual Model::GetCodeSigningConfigOutcome GetCodeSigningConfig(const Model::GetCodeSigningConfigRequest& request) const;
 
  template <typename GetCodeSigningConfigRequestT = Model::GetCodeSigningConfigRequest>
  Model::GetCodeSigningConfigOutcomeCallable GetCodeSigningConfigCallable(const GetCodeSigningConfigRequestT& request) const {
    return SubmitCallable(&LambdaClient::GetCodeSigningConfig, request);
  }
 
  template <typename GetCodeSigningConfigRequestT = Model::GetCodeSigningConfigRequest>
  void GetCodeSigningConfigAsync(const GetCodeSigningConfigRequestT& request, const GetCodeSigningConfigResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::GetCodeSigningConfig, request, handler, context);
  }
 
  virtual Model::GetDurableExecutionOutcome GetDurableExecution(const Model::GetDurableExecutionRequest& request) const;
 
  template <typename GetDurableExecutionRequestT = Model::GetDurableExecutionRequest>
  Model::GetDurableExecutionOutcomeCallable GetDurableExecutionCallable(const GetDurableExecutionRequestT& request) const {
    return SubmitCallable(&LambdaClient::GetDurableExecution, request);
  }
 
  template <typename GetDurableExecutionRequestT = Model::GetDurableExecutionRequest>
  void GetDurableExecutionAsync(const GetDurableExecutionRequestT& request, const GetDurableExecutionResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::GetDurableExecution, request, handler, context);
  }
 
  virtual Model::GetDurableExecutionHistoryOutcome GetDurableExecutionHistory(
      const Model::GetDurableExecutionHistoryRequest& request) const;
 
  template <typename GetDurableExecutionHistoryRequestT = Model::GetDurableExecutionHistoryRequest>
  Model::GetDurableExecutionHistoryOutcomeCallable GetDurableExecutionHistoryCallable(
      const GetDurableExecutionHistoryRequestT& request) const {
    return SubmitCallable(&LambdaClient::GetDurableExecutionHistory, request);
  }
 
  template <typename GetDurableExecutionHistoryRequestT = Model::GetDurableExecutionHistoryRequest>
  void GetDurableExecutionHistoryAsync(const GetDurableExecutionHistoryRequestT& request,
                                       const GetDurableExecutionHistoryResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::GetDurableExecutionHistory, request, handler, context);
  }
 
  virtual Model::GetDurableExecutionStateOutcome GetDurableExecutionState(const Model::GetDurableExecutionStateRequest& request) const;
 
  template <typename GetDurableExecutionStateRequestT = Model::GetDurableExecutionStateRequest>
  Model::GetDurableExecutionStateOutcomeCallable GetDurableExecutionStateCallable(const GetDurableExecutionStateRequestT& request) const {
    return SubmitCallable(&LambdaClient::GetDurableExecutionState, request);
  }
 
  template <typename GetDurableExecutionStateRequestT = Model::GetDurableExecutionStateRequest>
  void GetDurableExecutionStateAsync(const GetDurableExecutionStateRequestT& request,
                                     const GetDurableExecutionStateResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::GetDurableExecutionState, request, handler, context);
  }
 
  virtual Model::GetEventSourceMappingOutcome GetEventSourceMapping(const Model::GetEventSourceMappingRequest& request) const;
 
  template <typename GetEventSourceMappingRequestT = Model::GetEventSourceMappingRequest>
  Model::GetEventSourceMappingOutcomeCallable GetEventSourceMappingCallable(const GetEventSourceMappingRequestT& request) const {
    return SubmitCallable(&LambdaClient::GetEventSourceMapping, request);
  }
 
  template <typename GetEventSourceMappingRequestT = Model::GetEventSourceMappingRequest>
  void GetEventSourceMappingAsync(const GetEventSourceMappingRequestT& request, const GetEventSourceMappingResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::GetEventSourceMapping, request, handler, context);
  }
 
  virtual Model::GetFunctionOutcome GetFunction(const Model::GetFunctionRequest& request) const;
 
  template <typename GetFunctionRequestT = Model::GetFunctionRequest>
  Model::GetFunctionOutcomeCallable GetFunctionCallable(const GetFunctionRequestT& request) const {
    return SubmitCallable(&LambdaClient::GetFunction, request);
  }
 
  template <typename GetFunctionRequestT = Model::GetFunctionRequest>
  void GetFunctionAsync(const GetFunctionRequestT& request, const GetFunctionResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::GetFunction, request, handler, context);
  }
 
  virtual Model::GetFunctionCodeSigningConfigOutcome GetFunctionCodeSigningConfig(
      const Model::GetFunctionCodeSigningConfigRequest& request) const;
 
  template <typename GetFunctionCodeSigningConfigRequestT = Model::GetFunctionCodeSigningConfigRequest>
  Model::GetFunctionCodeSigningConfigOutcomeCallable GetFunctionCodeSigningConfigCallable(
      const GetFunctionCodeSigningConfigRequestT& request) const {
    return SubmitCallable(&LambdaClient::GetFunctionCodeSigningConfig, request);
  }
 
  template <typename GetFunctionCodeSigningConfigRequestT = Model::GetFunctionCodeSigningConfigRequest>
  void GetFunctionCodeSigningConfigAsync(const GetFunctionCodeSigningConfigRequestT& request,
                                         const GetFunctionCodeSigningConfigResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::GetFunctionCodeSigningConfig, request, handler, context);
  }
 
  virtual Model::GetFunctionConcurrencyOutcome GetFunctionConcurrency(const Model::GetFunctionConcurrencyRequest& request) const;
 
  template <typename GetFunctionConcurrencyRequestT = Model::GetFunctionConcurrencyRequest>
  Model::GetFunctionConcurrencyOutcomeCallable GetFunctionConcurrencyCallable(const GetFunctionConcurrencyRequestT& request) const {
    return SubmitCallable(&LambdaClient::GetFunctionConcurrency, request);
  }
 
  template <typename GetFunctionConcurrencyRequestT = Model::GetFunctionConcurrencyRequest>
  void GetFunctionConcurrencyAsync(const GetFunctionConcurrencyRequestT& request,
                                   const GetFunctionConcurrencyResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::GetFunctionConcurrency, request, handler, context);
  }
 
  virtual Model::GetFunctionConfigurationOutcome GetFunctionConfiguration(const Model::GetFunctionConfigurationRequest& request) const;
 
  template <typename GetFunctionConfigurationRequestT = Model::GetFunctionConfigurationRequest>
  Model::GetFunctionConfigurationOutcomeCallable GetFunctionConfigurationCallable(const GetFunctionConfigurationRequestT& request) const {
    return SubmitCallable(&LambdaClient::GetFunctionConfiguration, request);
  }
 
  template <typename GetFunctionConfigurationRequestT = Model::GetFunctionConfigurationRequest>
  void GetFunctionConfigurationAsync(const GetFunctionConfigurationRequestT& request,
                                     const GetFunctionConfigurationResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::GetFunctionConfiguration, request, handler, context);
  }
 
  virtual Model::GetFunctionEventInvokeConfigOutcome GetFunctionEventInvokeConfig(
      const Model::GetFunctionEventInvokeConfigRequest& request) const;
 
  template <typename GetFunctionEventInvokeConfigRequestT = Model::GetFunctionEventInvokeConfigRequest>
  Model::GetFunctionEventInvokeConfigOutcomeCallable GetFunctionEventInvokeConfigCallable(
      const GetFunctionEventInvokeConfigRequestT& request) const {
    return SubmitCallable(&LambdaClient::GetFunctionEventInvokeConfig, request);
  }
 
  template <typename GetFunctionEventInvokeConfigRequestT = Model::GetFunctionEventInvokeConfigRequest>
  void GetFunctionEventInvokeConfigAsync(const GetFunctionEventInvokeConfigRequestT& request,
                                         const GetFunctionEventInvokeConfigResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::GetFunctionEventInvokeConfig, request, handler, context);
  }
 
  virtual Model::GetFunctionRecursionConfigOutcome GetFunctionRecursionConfig(
      const Model::GetFunctionRecursionConfigRequest& request) const;
 
  template <typename GetFunctionRecursionConfigRequestT = Model::GetFunctionRecursionConfigRequest>
  Model::GetFunctionRecursionConfigOutcomeCallable GetFunctionRecursionConfigCallable(
      const GetFunctionRecursionConfigRequestT& request) const {
    return SubmitCallable(&LambdaClient::GetFunctionRecursionConfig, request);
  }
 
  template <typename GetFunctionRecursionConfigRequestT = Model::GetFunctionRecursionConfigRequest>
  void GetFunctionRecursionConfigAsync(const GetFunctionRecursionConfigRequestT& request,
                                       const GetFunctionRecursionConfigResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::GetFunctionRecursionConfig, request, handler, context);
  }
 
  virtual Model::GetFunctionScalingConfigOutcome GetFunctionScalingConfig(const Model::GetFunctionScalingConfigRequest& request) const;
 
  template <typename GetFunctionScalingConfigRequestT = Model::GetFunctionScalingConfigRequest>
  Model::GetFunctionScalingConfigOutcomeCallable GetFunctionScalingConfigCallable(const GetFunctionScalingConfigRequestT& request) const {
    return SubmitCallable(&LambdaClient::GetFunctionScalingConfig, request);
  }
 
  template <typename GetFunctionScalingConfigRequestT = Model::GetFunctionScalingConfigRequest>
  void GetFunctionScalingConfigAsync(const GetFunctionScalingConfigRequestT& request,
                                     const GetFunctionScalingConfigResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::GetFunctionScalingConfig, request, handler, context);
  }
 
  virtual Model::GetFunctionUrlConfigOutcome GetFunctionUrlConfig(const Model::GetFunctionUrlConfigRequest& request) const;
 
  template <typename GetFunctionUrlConfigRequestT = Model::GetFunctionUrlConfigRequest>
  Model::GetFunctionUrlConfigOutcomeCallable GetFunctionUrlConfigCallable(const GetFunctionUrlConfigRequestT& request) const {
    return SubmitCallable(&LambdaClient::GetFunctionUrlConfig, request);
  }
 
  template <typename GetFunctionUrlConfigRequestT = Model::GetFunctionUrlConfigRequest>
  void GetFunctionUrlConfigAsync(const GetFunctionUrlConfigRequestT& request, const GetFunctionUrlConfigResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::GetFunctionUrlConfig, request, handler, context);
  }
 
  virtual Model::GetLayerVersionOutcome GetLayerVersion(const Model::GetLayerVersionRequest& request) const;
 
  template <typename GetLayerVersionRequestT = Model::GetLayerVersionRequest>
  Model::GetLayerVersionOutcomeCallable GetLayerVersionCallable(const GetLayerVersionRequestT& request) const {
    return SubmitCallable(&LambdaClient::GetLayerVersion, request);
  }
 
  template <typename GetLayerVersionRequestT = Model::GetLayerVersionRequest>
  void GetLayerVersionAsync(const GetLayerVersionRequestT& request, const GetLayerVersionResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::GetLayerVersion, request, handler, context);
  }
 
  virtual Model::GetLayerVersionByArnOutcome GetLayerVersionByArn(const Model::GetLayerVersionByArnRequest& request) const;
 
  template <typename GetLayerVersionByArnRequestT = Model::GetLayerVersionByArnRequest>
  Model::GetLayerVersionByArnOutcomeCallable GetLayerVersionByArnCallable(const GetLayerVersionByArnRequestT& request) const {
    return SubmitCallable(&LambdaClient::GetLayerVersionByArn, request);
  }
 
  template <typename GetLayerVersionByArnRequestT = Model::GetLayerVersionByArnRequest>
  void GetLayerVersionByArnAsync(const GetLayerVersionByArnRequestT& request, const GetLayerVersionByArnResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::GetLayerVersionByArn, request, handler, context);
  }
 
  virtual Model::GetLayerVersionPolicyOutcome GetLayerVersionPolicy(const Model::GetLayerVersionPolicyRequest& request) const;
 
  template <typename GetLayerVersionPolicyRequestT = Model::GetLayerVersionPolicyRequest>
  Model::GetLayerVersionPolicyOutcomeCallable GetLayerVersionPolicyCallable(const GetLayerVersionPolicyRequestT& request) const {
    return SubmitCallable(&LambdaClient::GetLayerVersionPolicy, request);
  }
 
  template <typename GetLayerVersionPolicyRequestT = Model::GetLayerVersionPolicyRequest>
  void GetLayerVersionPolicyAsync(const GetLayerVersionPolicyRequestT& request, const GetLayerVersionPolicyResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::GetLayerVersionPolicy, request, handler, context);
  }
 
  virtual Model::GetPolicyOutcome GetPolicy(const Model::GetPolicyRequest& request) const;
 
  template <typename GetPolicyRequestT = Model::GetPolicyRequest>
  Model::GetPolicyOutcomeCallable GetPolicyCallable(const GetPolicyRequestT& request) const {
    return SubmitCallable(&LambdaClient::GetPolicy, request);
  }
 
  template <typename GetPolicyRequestT = Model::GetPolicyRequest>
  void GetPolicyAsync(const GetPolicyRequestT& request, const GetPolicyResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::GetPolicy, request, handler, context);
  }
 
  virtual Model::GetProvisionedConcurrencyConfigOutcome GetProvisionedConcurrencyConfig(
      const Model::GetProvisionedConcurrencyConfigRequest& request) const;
 
  template <typename GetProvisionedConcurrencyConfigRequestT = Model::GetProvisionedConcurrencyConfigRequest>
  Model::GetProvisionedConcurrencyConfigOutcomeCallable GetProvisionedConcurrencyConfigCallable(
      const GetProvisionedConcurrencyConfigRequestT& request) const {
    return SubmitCallable(&LambdaClient::GetProvisionedConcurrencyConfig, request);
  }
 
  template <typename GetProvisionedConcurrencyConfigRequestT = Model::GetProvisionedConcurrencyConfigRequest>
  void GetProvisionedConcurrencyConfigAsync(const GetProvisionedConcurrencyConfigRequestT& request,
                                            const GetProvisionedConcurrencyConfigResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::GetProvisionedConcurrencyConfig, request, handler, context);
  }
 
  virtual Model::GetRuntimeManagementConfigOutcome GetRuntimeManagementConfig(
      const Model::GetRuntimeManagementConfigRequest& request) const;
 
  template <typename GetRuntimeManagementConfigRequestT = Model::GetRuntimeManagementConfigRequest>
  Model::GetRuntimeManagementConfigOutcomeCallable GetRuntimeManagementConfigCallable(
      const GetRuntimeManagementConfigRequestT& request) const {
    return SubmitCallable(&LambdaClient::GetRuntimeManagementConfig, request);
  }
 
  template <typename GetRuntimeManagementConfigRequestT = Model::GetRuntimeManagementConfigRequest>
  void GetRuntimeManagementConfigAsync(const GetRuntimeManagementConfigRequestT& request,
                                       const GetRuntimeManagementConfigResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::GetRuntimeManagementConfig, request, handler, context);
  }
 
  virtual Model::InvokeOutcome Invoke(const Model::InvokeRequest& request) const;
 
  template <typename InvokeRequestT = Model::InvokeRequest>
  Model::InvokeOutcomeCallable InvokeCallable(const InvokeRequestT& request) const {
    return SubmitCallable(&LambdaClient::Invoke, request);
  }
 
  template <typename InvokeRequestT = Model::InvokeRequest>
  void InvokeAsync(const InvokeRequestT& request, const InvokeResponseReceivedHandler& handler,
                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::Invoke, request, handler, context);
  }
 
  virtual Model::InvokeWithResponseStreamOutcome InvokeWithResponseStream(Model::InvokeWithResponseStreamRequest& request) const;
 
  template <typename InvokeWithResponseStreamRequestT = Model::InvokeWithResponseStreamRequest>
  Model::InvokeWithResponseStreamOutcomeCallable InvokeWithResponseStreamCallable(InvokeWithResponseStreamRequestT& request) const {
    return SubmitCallable(&LambdaClient::InvokeWithResponseStream, request);
  }
 
  template <typename InvokeWithResponseStreamRequestT = Model::InvokeWithResponseStreamRequest>
  void InvokeWithResponseStreamAsync(InvokeWithResponseStreamRequestT& request,
                                     const InvokeWithResponseStreamResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::InvokeWithResponseStream, request, handler, context);
  }
 
  virtual Model::ListAliasesOutcome ListAliases(const Model::ListAliasesRequest& request) const;
 
  template <typename ListAliasesRequestT = Model::ListAliasesRequest>
  Model::ListAliasesOutcomeCallable ListAliasesCallable(const ListAliasesRequestT& request) const {
    return SubmitCallable(&LambdaClient::ListAliases, request);
  }
 
  template <typename ListAliasesRequestT = Model::ListAliasesRequest>
  void ListAliasesAsync(const ListAliasesRequestT& request, const ListAliasesResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::ListAliases, request, handler, context);
  }
 
  virtual Model::ListCapacityProvidersOutcome ListCapacityProviders(const Model::ListCapacityProvidersRequest& request = {}) const;
 
  template <typename ListCapacityProvidersRequestT = Model::ListCapacityProvidersRequest>
  Model::ListCapacityProvidersOutcomeCallable ListCapacityProvidersCallable(const ListCapacityProvidersRequestT& request = {}) const {
    return SubmitCallable(&LambdaClient::ListCapacityProviders, request);
  }
 
  template <typename ListCapacityProvidersRequestT = Model::ListCapacityProvidersRequest>
  void ListCapacityProvidersAsync(const ListCapacityProvidersResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                  const ListCapacityProvidersRequestT& request = {}) const {
    return SubmitAsync(&LambdaClient::ListCapacityProviders, request, handler, context);
  }
 
  virtual Model::ListCodeSigningConfigsOutcome ListCodeSigningConfigs(const Model::ListCodeSigningConfigsRequest& request = {}) const;
 
  template <typename ListCodeSigningConfigsRequestT = Model::ListCodeSigningConfigsRequest>
  Model::ListCodeSigningConfigsOutcomeCallable ListCodeSigningConfigsCallable(const ListCodeSigningConfigsRequestT& request = {}) const {
    return SubmitCallable(&LambdaClient::ListCodeSigningConfigs, request);
  }
 
  template <typename ListCodeSigningConfigsRequestT = Model::ListCodeSigningConfigsRequest>
  void ListCodeSigningConfigsAsync(const ListCodeSigningConfigsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                   const ListCodeSigningConfigsRequestT& request = {}) const {
    return SubmitAsync(&LambdaClient::ListCodeSigningConfigs, request, handler, context);
  }
 
  virtual Model::ListDurableExecutionsByFunctionOutcome ListDurableExecutionsByFunction(
      const Model::ListDurableExecutionsByFunctionRequest& request) const;
 
  template <typename ListDurableExecutionsByFunctionRequestT = Model::ListDurableExecutionsByFunctionRequest>
  Model::ListDurableExecutionsByFunctionOutcomeCallable ListDurableExecutionsByFunctionCallable(
      const ListDurableExecutionsByFunctionRequestT& request) const {
    return SubmitCallable(&LambdaClient::ListDurableExecutionsByFunction, request);
  }
 
  template <typename ListDurableExecutionsByFunctionRequestT = Model::ListDurableExecutionsByFunctionRequest>
  void ListDurableExecutionsByFunctionAsync(const ListDurableExecutionsByFunctionRequestT& request,
                                            const ListDurableExecutionsByFunctionResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::ListDurableExecutionsByFunction, request, handler, context);
  }
 
  virtual Model::ListEventSourceMappingsOutcome ListEventSourceMappings(const Model::ListEventSourceMappingsRequest& request = {}) const;
 
  template <typename ListEventSourceMappingsRequestT = Model::ListEventSourceMappingsRequest>
  Model::ListEventSourceMappingsOutcomeCallable ListEventSourceMappingsCallable(const ListEventSourceMappingsRequestT& request = {}) const {
    return SubmitCallable(&LambdaClient::ListEventSourceMappings, request);
  }
 
  template <typename ListEventSourceMappingsRequestT = Model::ListEventSourceMappingsRequest>
  void ListEventSourceMappingsAsync(const ListEventSourceMappingsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const ListEventSourceMappingsRequestT& request = {}) const {
    return SubmitAsync(&LambdaClient::ListEventSourceMappings, request, handler, context);
  }
 
  virtual Model::ListFunctionEventInvokeConfigsOutcome ListFunctionEventInvokeConfigs(
      const Model::ListFunctionEventInvokeConfigsRequest& request) const;
 
  template <typename ListFunctionEventInvokeConfigsRequestT = Model::ListFunctionEventInvokeConfigsRequest>
  Model::ListFunctionEventInvokeConfigsOutcomeCallable ListFunctionEventInvokeConfigsCallable(
      const ListFunctionEventInvokeConfigsRequestT& request) const {
    return SubmitCallable(&LambdaClient::ListFunctionEventInvokeConfigs, request);
  }
 
  template <typename ListFunctionEventInvokeConfigsRequestT = Model::ListFunctionEventInvokeConfigsRequest>
  void ListFunctionEventInvokeConfigsAsync(const ListFunctionEventInvokeConfigsRequestT& request,
                                           const ListFunctionEventInvokeConfigsResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::ListFunctionEventInvokeConfigs, request, handler, context);
  }
 
  virtual Model::ListFunctionUrlConfigsOutcome ListFunctionUrlConfigs(const Model::ListFunctionUrlConfigsRequest& request) const;
 
  template <typename ListFunctionUrlConfigsRequestT = Model::ListFunctionUrlConfigsRequest>
  Model::ListFunctionUrlConfigsOutcomeCallable ListFunctionUrlConfigsCallable(const ListFunctionUrlConfigsRequestT& request) const {
    return SubmitCallable(&LambdaClient::ListFunctionUrlConfigs, request);
  }
 
  template <typename ListFunctionUrlConfigsRequestT = Model::ListFunctionUrlConfigsRequest>
  void ListFunctionUrlConfigsAsync(const ListFunctionUrlConfigsRequestT& request,
                                   const ListFunctionUrlConfigsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::ListFunctionUrlConfigs, request, handler, context);
  }
 
  virtual Model::ListFunctionVersionsByCapacityProviderOutcome ListFunctionVersionsByCapacityProvider(
      const Model::ListFunctionVersionsByCapacityProviderRequest& request) const;
 
  template <typename ListFunctionVersionsByCapacityProviderRequestT = Model::ListFunctionVersionsByCapacityProviderRequest>
  Model::ListFunctionVersionsByCapacityProviderOutcomeCallable ListFunctionVersionsByCapacityProviderCallable(
      const ListFunctionVersionsByCapacityProviderRequestT& request) const {
    return SubmitCallable(&LambdaClient::ListFunctionVersionsByCapacityProvider, request);
  }
 
  template <typename ListFunctionVersionsByCapacityProviderRequestT = Model::ListFunctionVersionsByCapacityProviderRequest>
  void ListFunctionVersionsByCapacityProviderAsync(const ListFunctionVersionsByCapacityProviderRequestT& request,
                                                   const ListFunctionVersionsByCapacityProviderResponseReceivedHandler& handler,
                                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::ListFunctionVersionsByCapacityProvider, request, handler, context);
  }
 
  virtual Model::ListFunctionsOutcome ListFunctions(const Model::ListFunctionsRequest& request = {}) const;
 
  template <typename ListFunctionsRequestT = Model::ListFunctionsRequest>
  Model::ListFunctionsOutcomeCallable ListFunctionsCallable(const ListFunctionsRequestT& request = {}) const {
    return SubmitCallable(&LambdaClient::ListFunctions, request);
  }
 
  template <typename ListFunctionsRequestT = Model::ListFunctionsRequest>
  void ListFunctionsAsync(const ListFunctionsResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                          const ListFunctionsRequestT& request = {}) const {
    return SubmitAsync(&LambdaClient::ListFunctions, request, handler, context);
  }
 
  virtual Model::ListFunctionsByCodeSigningConfigOutcome ListFunctionsByCodeSigningConfig(
      const Model::ListFunctionsByCodeSigningConfigRequest& request) const;
 
  template <typename ListFunctionsByCodeSigningConfigRequestT = Model::ListFunctionsByCodeSigningConfigRequest>
  Model::ListFunctionsByCodeSigningConfigOutcomeCallable ListFunctionsByCodeSigningConfigCallable(
      const ListFunctionsByCodeSigningConfigRequestT& request) const {
    return SubmitCallable(&LambdaClient::ListFunctionsByCodeSigningConfig, request);
  }
 
  template <typename ListFunctionsByCodeSigningConfigRequestT = Model::ListFunctionsByCodeSigningConfigRequest>
  void ListFunctionsByCodeSigningConfigAsync(const ListFunctionsByCodeSigningConfigRequestT& request,
                                             const ListFunctionsByCodeSigningConfigResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::ListFunctionsByCodeSigningConfig, request, handler, context);
  }
 
  virtual Model::ListLayerVersionsOutcome ListLayerVersions(const Model::ListLayerVersionsRequest& request) const;
 
  template <typename ListLayerVersionsRequestT = Model::ListLayerVersionsRequest>
  Model::ListLayerVersionsOutcomeCallable ListLayerVersionsCallable(const ListLayerVersionsRequestT& request) const {
    return SubmitCallable(&LambdaClient::ListLayerVersions, request);
  }
 
  template <typename ListLayerVersionsRequestT = Model::ListLayerVersionsRequest>
  void ListLayerVersionsAsync(const ListLayerVersionsRequestT& request, const ListLayerVersionsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::ListLayerVersions, request, handler, context);
  }
 
  virtual Model::ListLayersOutcome ListLayers(const Model::ListLayersRequest& request = {}) const;
 
  template <typename ListLayersRequestT = Model::ListLayersRequest>
  Model::ListLayersOutcomeCallable ListLayersCallable(const ListLayersRequestT& request = {}) const {
    return SubmitCallable(&LambdaClient::ListLayers, request);
  }
 
  template <typename ListLayersRequestT = Model::ListLayersRequest>
  void ListLayersAsync(const ListLayersResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                       const ListLayersRequestT& request = {}) const {
    return SubmitAsync(&LambdaClient::ListLayers, request, handler, context);
  }
 
  virtual Model::ListProvisionedConcurrencyConfigsOutcome ListProvisionedConcurrencyConfigs(
      const Model::ListProvisionedConcurrencyConfigsRequest& request) const;
 
  template <typename ListProvisionedConcurrencyConfigsRequestT = Model::ListProvisionedConcurrencyConfigsRequest>
  Model::ListProvisionedConcurrencyConfigsOutcomeCallable ListProvisionedConcurrencyConfigsCallable(
      const ListProvisionedConcurrencyConfigsRequestT& request) const {
    return SubmitCallable(&LambdaClient::ListProvisionedConcurrencyConfigs, request);
  }
 
  template <typename ListProvisionedConcurrencyConfigsRequestT = Model::ListProvisionedConcurrencyConfigsRequest>
  void ListProvisionedConcurrencyConfigsAsync(const ListProvisionedConcurrencyConfigsRequestT& request,
                                              const ListProvisionedConcurrencyConfigsResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::ListProvisionedConcurrencyConfigs, 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(&LambdaClient::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(&LambdaClient::ListTags, request, handler, context);
  }
 
  virtual Model::ListVersionsByFunctionOutcome ListVersionsByFunction(const Model::ListVersionsByFunctionRequest& request) const;
 
  template <typename ListVersionsByFunctionRequestT = Model::ListVersionsByFunctionRequest>
  Model::ListVersionsByFunctionOutcomeCallable ListVersionsByFunctionCallable(const ListVersionsByFunctionRequestT& request) const {
    return SubmitCallable(&LambdaClient::ListVersionsByFunction, request);
  }
 
  template <typename ListVersionsByFunctionRequestT = Model::ListVersionsByFunctionRequest>
  void ListVersionsByFunctionAsync(const ListVersionsByFunctionRequestT& request,
                                   const ListVersionsByFunctionResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::ListVersionsByFunction, request, handler, context);
  }
 
  virtual Model::PublishLayerVersionOutcome PublishLayerVersion(const Model::PublishLayerVersionRequest& request) const;
 
  template <typename PublishLayerVersionRequestT = Model::PublishLayerVersionRequest>
  Model::PublishLayerVersionOutcomeCallable PublishLayerVersionCallable(const PublishLayerVersionRequestT& request) const {
    return SubmitCallable(&LambdaClient::PublishLayerVersion, request);
  }
 
  template <typename PublishLayerVersionRequestT = Model::PublishLayerVersionRequest>
  void PublishLayerVersionAsync(const PublishLayerVersionRequestT& request, const PublishLayerVersionResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::PublishLayerVersion, request, handler, context);
  }
 
  virtual Model::PublishVersionOutcome PublishVersion(const Model::PublishVersionRequest& request) const;
 
  template <typename PublishVersionRequestT = Model::PublishVersionRequest>
  Model::PublishVersionOutcomeCallable PublishVersionCallable(const PublishVersionRequestT& request) const {
    return SubmitCallable(&LambdaClient::PublishVersion, request);
  }
 
  template <typename PublishVersionRequestT = Model::PublishVersionRequest>
  void PublishVersionAsync(const PublishVersionRequestT& request, const PublishVersionResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::PublishVersion, request, handler, context);
  }
 
  virtual Model::PutFunctionCodeSigningConfigOutcome PutFunctionCodeSigningConfig(
      const Model::PutFunctionCodeSigningConfigRequest& request) const;
 
  template <typename PutFunctionCodeSigningConfigRequestT = Model::PutFunctionCodeSigningConfigRequest>
  Model::PutFunctionCodeSigningConfigOutcomeCallable PutFunctionCodeSigningConfigCallable(
      const PutFunctionCodeSigningConfigRequestT& request) const {
    return SubmitCallable(&LambdaClient::PutFunctionCodeSigningConfig, request);
  }
 
  template <typename PutFunctionCodeSigningConfigRequestT = Model::PutFunctionCodeSigningConfigRequest>
  void PutFunctionCodeSigningConfigAsync(const PutFunctionCodeSigningConfigRequestT& request,
                                         const PutFunctionCodeSigningConfigResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::PutFunctionCodeSigningConfig, request, handler, context);
  }
 
  virtual Model::PutFunctionConcurrencyOutcome PutFunctionConcurrency(const Model::PutFunctionConcurrencyRequest& request) const;
 
  template <typename PutFunctionConcurrencyRequestT = Model::PutFunctionConcurrencyRequest>
  Model::PutFunctionConcurrencyOutcomeCallable PutFunctionConcurrencyCallable(const PutFunctionConcurrencyRequestT& request) const {
    return SubmitCallable(&LambdaClient::PutFunctionConcurrency, request);
  }
 
  template <typename PutFunctionConcurrencyRequestT = Model::PutFunctionConcurrencyRequest>
  void PutFunctionConcurrencyAsync(const PutFunctionConcurrencyRequestT& request,
                                   const PutFunctionConcurrencyResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::PutFunctionConcurrency, request, handler, context);
  }
 
  virtual Model::PutFunctionEventInvokeConfigOutcome PutFunctionEventInvokeConfig(
      const Model::PutFunctionEventInvokeConfigRequest& request) const;
 
  template <typename PutFunctionEventInvokeConfigRequestT = Model::PutFunctionEventInvokeConfigRequest>
  Model::PutFunctionEventInvokeConfigOutcomeCallable PutFunctionEventInvokeConfigCallable(
      const PutFunctionEventInvokeConfigRequestT& request) const {
    return SubmitCallable(&LambdaClient::PutFunctionEventInvokeConfig, request);
  }
 
  template <typename PutFunctionEventInvokeConfigRequestT = Model::PutFunctionEventInvokeConfigRequest>
  void PutFunctionEventInvokeConfigAsync(const PutFunctionEventInvokeConfigRequestT& request,
                                         const PutFunctionEventInvokeConfigResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::PutFunctionEventInvokeConfig, request, handler, context);
  }
 
  virtual Model::PutFunctionRecursionConfigOutcome PutFunctionRecursionConfig(
      const Model::PutFunctionRecursionConfigRequest& request) const;
 
  template <typename PutFunctionRecursionConfigRequestT = Model::PutFunctionRecursionConfigRequest>
  Model::PutFunctionRecursionConfigOutcomeCallable PutFunctionRecursionConfigCallable(
      const PutFunctionRecursionConfigRequestT& request) const {
    return SubmitCallable(&LambdaClient::PutFunctionRecursionConfig, request);
  }
 
  template <typename PutFunctionRecursionConfigRequestT = Model::PutFunctionRecursionConfigRequest>
  void PutFunctionRecursionConfigAsync(const PutFunctionRecursionConfigRequestT& request,
                                       const PutFunctionRecursionConfigResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::PutFunctionRecursionConfig, request, handler, context);
  }
 
  virtual Model::PutFunctionScalingConfigOutcome PutFunctionScalingConfig(const Model::PutFunctionScalingConfigRequest& request) const;
 
  template <typename PutFunctionScalingConfigRequestT = Model::PutFunctionScalingConfigRequest>
  Model::PutFunctionScalingConfigOutcomeCallable PutFunctionScalingConfigCallable(const PutFunctionScalingConfigRequestT& request) const {
    return SubmitCallable(&LambdaClient::PutFunctionScalingConfig, request);
  }
 
  template <typename PutFunctionScalingConfigRequestT = Model::PutFunctionScalingConfigRequest>
  void PutFunctionScalingConfigAsync(const PutFunctionScalingConfigRequestT& request,
                                     const PutFunctionScalingConfigResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::PutFunctionScalingConfig, request, handler, context);
  }
 
  virtual Model::PutProvisionedConcurrencyConfigOutcome PutProvisionedConcurrencyConfig(
      const Model::PutProvisionedConcurrencyConfigRequest& request) const;
 
  template <typename PutProvisionedConcurrencyConfigRequestT = Model::PutProvisionedConcurrencyConfigRequest>
  Model::PutProvisionedConcurrencyConfigOutcomeCallable PutProvisionedConcurrencyConfigCallable(
      const PutProvisionedConcurrencyConfigRequestT& request) const {
    return SubmitCallable(&LambdaClient::PutProvisionedConcurrencyConfig, request);
  }
 
  template <typename PutProvisionedConcurrencyConfigRequestT = Model::PutProvisionedConcurrencyConfigRequest>
  void PutProvisionedConcurrencyConfigAsync(const PutProvisionedConcurrencyConfigRequestT& request,
                                            const PutProvisionedConcurrencyConfigResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::PutProvisionedConcurrencyConfig, request, handler, context);
  }
 
  virtual Model::PutRuntimeManagementConfigOutcome PutRuntimeManagementConfig(
      const Model::PutRuntimeManagementConfigRequest& request) const;
 
  template <typename PutRuntimeManagementConfigRequestT = Model::PutRuntimeManagementConfigRequest>
  Model::PutRuntimeManagementConfigOutcomeCallable PutRuntimeManagementConfigCallable(
      const PutRuntimeManagementConfigRequestT& request) const {
    return SubmitCallable(&LambdaClient::PutRuntimeManagementConfig, request);
  }
 
  template <typename PutRuntimeManagementConfigRequestT = Model::PutRuntimeManagementConfigRequest>
  void PutRuntimeManagementConfigAsync(const PutRuntimeManagementConfigRequestT& request,
                                       const PutRuntimeManagementConfigResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::PutRuntimeManagementConfig, request, handler, context);
  }
 
  virtual Model::RemoveLayerVersionPermissionOutcome RemoveLayerVersionPermission(
      const Model::RemoveLayerVersionPermissionRequest& request) const;
 
  template <typename RemoveLayerVersionPermissionRequestT = Model::RemoveLayerVersionPermissionRequest>
  Model::RemoveLayerVersionPermissionOutcomeCallable RemoveLayerVersionPermissionCallable(
      const RemoveLayerVersionPermissionRequestT& request) const {
    return SubmitCallable(&LambdaClient::RemoveLayerVersionPermission, request);
  }
 
  template <typename RemoveLayerVersionPermissionRequestT = Model::RemoveLayerVersionPermissionRequest>
  void RemoveLayerVersionPermissionAsync(const RemoveLayerVersionPermissionRequestT& request,
                                         const RemoveLayerVersionPermissionResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::RemoveLayerVersionPermission, request, handler, context);
  }
 
  virtual Model::RemovePermissionOutcome RemovePermission(const Model::RemovePermissionRequest& request) const;
 
  template <typename RemovePermissionRequestT = Model::RemovePermissionRequest>
  Model::RemovePermissionOutcomeCallable RemovePermissionCallable(const RemovePermissionRequestT& request) const {
    return SubmitCallable(&LambdaClient::RemovePermission, request);
  }
 
  template <typename RemovePermissionRequestT = Model::RemovePermissionRequest>
  void RemovePermissionAsync(const RemovePermissionRequestT& request, const RemovePermissionResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::RemovePermission, request, handler, context);
  }
 
  virtual Model::SendDurableExecutionCallbackFailureOutcome SendDurableExecutionCallbackFailure(
      const Model::SendDurableExecutionCallbackFailureRequest& request) const;
 
  template <typename SendDurableExecutionCallbackFailureRequestT = Model::SendDurableExecutionCallbackFailureRequest>
  Model::SendDurableExecutionCallbackFailureOutcomeCallable SendDurableExecutionCallbackFailureCallable(
      const SendDurableExecutionCallbackFailureRequestT& request) const {
    return SubmitCallable(&LambdaClient::SendDurableExecutionCallbackFailure, request);
  }
 
  template <typename SendDurableExecutionCallbackFailureRequestT = Model::SendDurableExecutionCallbackFailureRequest>
  void SendDurableExecutionCallbackFailureAsync(const SendDurableExecutionCallbackFailureRequestT& request,
                                                const SendDurableExecutionCallbackFailureResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::SendDurableExecutionCallbackFailure, request, handler, context);
  }
 
  virtual Model::SendDurableExecutionCallbackHeartbeatOutcome SendDurableExecutionCallbackHeartbeat(
      const Model::SendDurableExecutionCallbackHeartbeatRequest& request) const;
 
  template <typename SendDurableExecutionCallbackHeartbeatRequestT = Model::SendDurableExecutionCallbackHeartbeatRequest>
  Model::SendDurableExecutionCallbackHeartbeatOutcomeCallable SendDurableExecutionCallbackHeartbeatCallable(
      const SendDurableExecutionCallbackHeartbeatRequestT& request) const {
    return SubmitCallable(&LambdaClient::SendDurableExecutionCallbackHeartbeat, request);
  }
 
  template <typename SendDurableExecutionCallbackHeartbeatRequestT = Model::SendDurableExecutionCallbackHeartbeatRequest>
  void SendDurableExecutionCallbackHeartbeatAsync(const SendDurableExecutionCallbackHeartbeatRequestT& request,
                                                  const SendDurableExecutionCallbackHeartbeatResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::SendDurableExecutionCallbackHeartbeat, request, handler, context);
  }
 
  virtual Model::SendDurableExecutionCallbackSuccessOutcome SendDurableExecutionCallbackSuccess(
      const Model::SendDurableExecutionCallbackSuccessRequest& request) const;
 
  template <typename SendDurableExecutionCallbackSuccessRequestT = Model::SendDurableExecutionCallbackSuccessRequest>
  Model::SendDurableExecutionCallbackSuccessOutcomeCallable SendDurableExecutionCallbackSuccessCallable(
      const SendDurableExecutionCallbackSuccessRequestT& request) const {
    return SubmitCallable(&LambdaClient::SendDurableExecutionCallbackSuccess, request);
  }
 
  template <typename SendDurableExecutionCallbackSuccessRequestT = Model::SendDurableExecutionCallbackSuccessRequest>
  void SendDurableExecutionCallbackSuccessAsync(const SendDurableExecutionCallbackSuccessRequestT& request,
                                                const SendDurableExecutionCallbackSuccessResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::SendDurableExecutionCallbackSuccess, request, handler, context);
  }
 
  virtual Model::StopDurableExecutionOutcome StopDurableExecution(const Model::StopDurableExecutionRequest& request) const;
 
  template <typename StopDurableExecutionRequestT = Model::StopDurableExecutionRequest>
  Model::StopDurableExecutionOutcomeCallable StopDurableExecutionCallable(const StopDurableExecutionRequestT& request) const {
    return SubmitCallable(&LambdaClient::StopDurableExecution, request);
  }
 
  template <typename StopDurableExecutionRequestT = Model::StopDurableExecutionRequest>
  void StopDurableExecutionAsync(const StopDurableExecutionRequestT& request, const StopDurableExecutionResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::StopDurableExecution, 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(&LambdaClient::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(&LambdaClient::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(&LambdaClient::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(&LambdaClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateAliasOutcome UpdateAlias(const Model::UpdateAliasRequest& request) const;
 
  template <typename UpdateAliasRequestT = Model::UpdateAliasRequest>
  Model::UpdateAliasOutcomeCallable UpdateAliasCallable(const UpdateAliasRequestT& request) const {
    return SubmitCallable(&LambdaClient::UpdateAlias, request);
  }
 
  template <typename UpdateAliasRequestT = Model::UpdateAliasRequest>
  void UpdateAliasAsync(const UpdateAliasRequestT& request, const UpdateAliasResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::UpdateAlias, request, handler, context);
  }
 
  virtual Model::UpdateCapacityProviderOutcome UpdateCapacityProvider(const Model::UpdateCapacityProviderRequest& request) const;
 
  template <typename UpdateCapacityProviderRequestT = Model::UpdateCapacityProviderRequest>
  Model::UpdateCapacityProviderOutcomeCallable UpdateCapacityProviderCallable(const UpdateCapacityProviderRequestT& request) const {
    return SubmitCallable(&LambdaClient::UpdateCapacityProvider, request);
  }
 
  template <typename UpdateCapacityProviderRequestT = Model::UpdateCapacityProviderRequest>
  void UpdateCapacityProviderAsync(const UpdateCapacityProviderRequestT& request,
                                   const UpdateCapacityProviderResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::UpdateCapacityProvider, request, handler, context);
  }
 
  virtual Model::UpdateCodeSigningConfigOutcome UpdateCodeSigningConfig(const Model::UpdateCodeSigningConfigRequest& request) const;
 
  template <typename UpdateCodeSigningConfigRequestT = Model::UpdateCodeSigningConfigRequest>
  Model::UpdateCodeSigningConfigOutcomeCallable UpdateCodeSigningConfigCallable(const UpdateCodeSigningConfigRequestT& request) const {
    return SubmitCallable(&LambdaClient::UpdateCodeSigningConfig, request);
  }
 
  template <typename UpdateCodeSigningConfigRequestT = Model::UpdateCodeSigningConfigRequest>
  void UpdateCodeSigningConfigAsync(const UpdateCodeSigningConfigRequestT& request,
                                    const UpdateCodeSigningConfigResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::UpdateCodeSigningConfig, request, handler, context);
  }
 
  virtual Model::UpdateEventSourceMappingOutcome UpdateEventSourceMapping(const Model::UpdateEventSourceMappingRequest& request) const;
 
  template <typename UpdateEventSourceMappingRequestT = Model::UpdateEventSourceMappingRequest>
  Model::UpdateEventSourceMappingOutcomeCallable UpdateEventSourceMappingCallable(const UpdateEventSourceMappingRequestT& request) const {
    return SubmitCallable(&LambdaClient::UpdateEventSourceMapping, request);
  }
 
  template <typename UpdateEventSourceMappingRequestT = Model::UpdateEventSourceMappingRequest>
  void UpdateEventSourceMappingAsync(const UpdateEventSourceMappingRequestT& request,
                                     const UpdateEventSourceMappingResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::UpdateEventSourceMapping, request, handler, context);
  }
 
  virtual Model::UpdateFunctionCodeOutcome UpdateFunctionCode(const Model::UpdateFunctionCodeRequest& request) const;
 
  template <typename UpdateFunctionCodeRequestT = Model::UpdateFunctionCodeRequest>
  Model::UpdateFunctionCodeOutcomeCallable UpdateFunctionCodeCallable(const UpdateFunctionCodeRequestT& request) const {
    return SubmitCallable(&LambdaClient::UpdateFunctionCode, request);
  }
 
  template <typename UpdateFunctionCodeRequestT = Model::UpdateFunctionCodeRequest>
  void UpdateFunctionCodeAsync(const UpdateFunctionCodeRequestT& request, const UpdateFunctionCodeResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::UpdateFunctionCode, request, handler, context);
  }
 
  virtual Model::UpdateFunctionConfigurationOutcome UpdateFunctionConfiguration(
      const Model::UpdateFunctionConfigurationRequest& request) const;
 
  template <typename UpdateFunctionConfigurationRequestT = Model::UpdateFunctionConfigurationRequest>
  Model::UpdateFunctionConfigurationOutcomeCallable UpdateFunctionConfigurationCallable(
      const UpdateFunctionConfigurationRequestT& request) const {
    return SubmitCallable(&LambdaClient::UpdateFunctionConfiguration, request);
  }
 
  template <typename UpdateFunctionConfigurationRequestT = Model::UpdateFunctionConfigurationRequest>
  void UpdateFunctionConfigurationAsync(const UpdateFunctionConfigurationRequestT& request,
                                        const UpdateFunctionConfigurationResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::UpdateFunctionConfiguration, request, handler, context);
  }
 
  virtual Model::UpdateFunctionEventInvokeConfigOutcome UpdateFunctionEventInvokeConfig(
      const Model::UpdateFunctionEventInvokeConfigRequest& request) const;
 
  template <typename UpdateFunctionEventInvokeConfigRequestT = Model::UpdateFunctionEventInvokeConfigRequest>
  Model::UpdateFunctionEventInvokeConfigOutcomeCallable UpdateFunctionEventInvokeConfigCallable(
      const UpdateFunctionEventInvokeConfigRequestT& request) const {
    return SubmitCallable(&LambdaClient::UpdateFunctionEventInvokeConfig, request);
  }
 
  template <typename UpdateFunctionEventInvokeConfigRequestT = Model::UpdateFunctionEventInvokeConfigRequest>
  void UpdateFunctionEventInvokeConfigAsync(const UpdateFunctionEventInvokeConfigRequestT& request,
                                            const UpdateFunctionEventInvokeConfigResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::UpdateFunctionEventInvokeConfig, request, handler, context);
  }
 
  virtual Model::UpdateFunctionUrlConfigOutcome UpdateFunctionUrlConfig(const Model::UpdateFunctionUrlConfigRequest& request) const;
 
  template <typename UpdateFunctionUrlConfigRequestT = Model::UpdateFunctionUrlConfigRequest>
  Model::UpdateFunctionUrlConfigOutcomeCallable UpdateFunctionUrlConfigCallable(const UpdateFunctionUrlConfigRequestT& request) const {
    return SubmitCallable(&LambdaClient::UpdateFunctionUrlConfig, request);
  }
 
  template <typename UpdateFunctionUrlConfigRequestT = Model::UpdateFunctionUrlConfigRequest>
  void UpdateFunctionUrlConfigAsync(const UpdateFunctionUrlConfigRequestT& request,
                                    const UpdateFunctionUrlConfigResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LambdaClient::UpdateFunctionUrlConfig, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<LambdaEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<LambdaClient>;
  void init(const LambdaClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, LambdaError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  LambdaClientConfiguration m_clientConfiguration;
  std::shared_ptr<LambdaEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace Lambda
}  // namespace Aws