LambdaClient.h

 
#pragma once
#include <aws/lambda/Lambda_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/lambda/LambdaServiceClientModel.h>
 
namespace Aws
{
namespace Lambda
{
  class AWS_LAMBDA_API LambdaClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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::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::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::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::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::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::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::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::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::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::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::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::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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<LambdaEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<LambdaClient>;
      void init(const LambdaClientConfiguration& clientConfiguration);
 
      LambdaClientConfiguration m_clientConfiguration;
      std::shared_ptr<LambdaEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace Lambda
} // namespace Aws