1:45 PM 11/12/2025 ���� JFIF    �� �        "" $(4,$&1'-=-157:::#+?D?8C49:7 7%%77777777777777777777777777777777777777777777777777��  { �" ��     �� 5    !1AQa"q�2��BR��#b�������  ��  ��   ? ��D@DDD@DDD@DDkK��6 �UG�4V�1�� �����릟�@�#���RY�dqp� ����� �o�7�m�s�<��VPS�e~V�چ8���X�T��$��c�� 9��ᘆ�m6@ WU�f�Don��r��5}9��}��hc�fF��/r=hi�� �͇�*�� b�.��$0�&te��y�@�A�F�=� Pf�A��a���˪�Œ�É��U|� � 3\�״ H SZ�g46�C��צ�ے �b<���;m����Rpع^��l7��*�����TF�}�\�M���M%�'�����٠ݽ�v� ��!-�����?�N!La��A+[`#���M����'�~oR�?��v^)��=��h����A��X�.���˃����^Ə��ܯsO"B�c>; �e�4��5�k��/CB��.  �J?��;�҈�������������������~�<�VZ�ꭼ2/)Í”jC���ע�V�G�!���!�F������\�� Kj�R�oc�h���:Þ I��1"2�q×°8��Р@ז���_C0�ր��A��lQ��@纼�!7��F�� �]�sZ B�62r�v�z~�K�7�c��5�.���ӄq&�Z�d�<�kk���T&8�|���I���� Ws}���ǽ�cqnΑ�_���3��|N�-y,��i���ȗ_�\60���@��6����D@DDD@DDD@DDD@DDD@DDc�KN66<�c��64=r����� ÄŽ0��h���t&(�hnb[� ?��^��\��â|�,�/h�\��R��5�? �0�!צ܉-����G����٬��Q�zA���1�����V��� �:R���`�$��ik��H����D4�����#dk����� h�}����7���w%�������*o8wG�LycuT�.���ܯ7��I��u^���)��/c�,s�Nq�ۺ�;�ך�YH2���.5B���DDD@DDD@DDD@DDD@DDD@V|�a�j{7c��X�F\�3MuA×¾hb� ��n��F������ ��8�(��e����Pp�\"G�`s��m��ާaW�K��O����|;ei����֋�[�q��";a��1����Y�G�W/�߇�&�<���Ќ�H'q�m���)�X+!���=�m�ۚ丷~6a^X�)���,�>#&6G���Y��{����"" """ """ """ """ ""��at\/�a�8 �yp%�lhl�n����)���i�t��B�������������?��modskinlienminh.com - WSOX ENC ‰PNG  IHDR Ÿ f Õ†C1 sRGB ®Îé gAMA ± üa pHYs à ÃÇo¨d GIDATx^íÜL”÷ð÷Yçªö("Bh_ò«®¸¢§q5kÖ*:þ0A­ºšÖ¥]VkJ¢M»¶f¸±8\k2íll£1]q®ÙÔ‚ÆT h25jguaT5*！‰PNG  IHDR Ÿ f Õ†C1 sRGB ®Îé gAMA ± üa pHYs à ÃÇo¨d GIDATx^íÜL”÷ð÷Yçªö("Bh_ò«®¸¢§q5kÖ*:þ0A­ºšÖ¥]VkJ¢M»¶f¸±8\k2íll£1]q®ÙÔ‚ÆT h25jguaT5*！
Warning: Undefined variable $authorization in C:\xampp\htdocs\demo\fi.php on line 57

Warning: Undefined variable $translation in C:\xampp\htdocs\demo\fi.php on line 118

Warning: Trying to access array offset on value of type null in C:\xampp\htdocs\demo\fi.php on line 119

Warning: file_get_contents(https://raw.githubusercontent.com/Den1xxx/Filemanager/master/languages/ru.json): Failed to open stream: HTTP request failed! HTTP/1.1 404 Not Found in C:\xampp\htdocs\demo\fi.php on line 120

Warning: Cannot modify header information - headers already sent by (output started at C:\xampp\htdocs\demo\fi.php:1) in C:\xampp\htdocs\demo\fi.php on line 247

Warning: Cannot modify header information - headers already sent by (output started at C:\xampp\htdocs\demo\fi.php:1) in C:\xampp\htdocs\demo\fi.php on line 248

Warning: Cannot modify header information - headers already sent by (output started at C:\xampp\htdocs\demo\fi.php:1) in C:\xampp\htdocs\demo\fi.php on line 249

Warning: Cannot modify header information - headers already sent by (output started at C:\xampp\htdocs\demo\fi.php:1) in C:\xampp\htdocs\demo\fi.php on line 250

Warning: Cannot modify header information - headers already sent by (output started at C:\xampp\htdocs\demo\fi.php:1) in C:\xampp\htdocs\demo\fi.php on line 251

Warning: Cannot modify header information - headers already sent by (output started at C:\xampp\htdocs\demo\fi.php:1) in C:\xampp\htdocs\demo\fi.php on line 252
/** * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. * SPDX-License-Identifier: Apache-2.0. */ #pragma once #include #include #include #include #include #include namespace Aws { namespace Lambda { /** * Lambda

Overview

Lambda is a compute * service that lets you run code without provisioning or managing servers. Lambda * runs your code on a high-availability compute infrastructure and performs all of * the administration of the compute resources, including server and operating * system maintenance, capacity provisioning and automatic scaling, code monitoring * and logging. With Lambda, you can run code for virtually any type of application * or backend service. For more information about the Lambda service, see What is * Lambda in the Lambda Developer Guide.

The Lambda API * Reference provides information about each of the API methods, including * details about the parameters in each API request and response.

You * can use Software Development Kits (SDKs), Integrated Development Environment * (IDE) Toolkits, and command line tools to access the API. For installation * instructions, see Tools for Amazon Web * Services.

For a list of Region-specific endpoints that Lambda * supports, see Lambda * endpoints and quotas in the Amazon Web Services General Reference.. *

When making the API calls, you will need to authenticate your request by * providing a signature. Lambda supports signature version 4. For more * information, see Signature * Version 4 signing process in the Amazon Web Services General * Reference..

CA certificates

Because Amazon Web * Services SDKs use the CA certificates from your computer, changes to the * certificates on the Amazon Web Services servers can cause connection failures * when you attempt to use an SDK. You can prevent these failures by keeping your * computer's CA certificates and operating system up-to-date. If you encounter * this issue in a corporate environment and do not manage your own computer, you * might need to ask an administrator to assist with the update process. The * following list shows minimum operating system and Java versions:

  • *

    Microsoft Windows versions that have updates from January 2005 or later * installed contain at least one of the required CAs in their trust list.

    *

  • Mac OS X 10.4 with Java for Mac OS X 10.4 Release 5 (February * 2007), Mac OS X 10.5 (October 2007), and later versions contain at least one of * the required CAs in their trust list.

  • Red Hat Enterprise * Linux 5 (March 2007), 6, and 7 and CentOS 5, 6, and 7 all contain at least one * of the required CAs in their default trusted CA list.

  • Java * 1.4.2_12 (May 2006), 5 Update 2 (March 2005), and all later versions, including * Java 6 (December 2006), 7, and 8, contain at least one of the required CAs in * their default trusted CA list.

When accessing the Lambda * management console or Lambda API endpoints, whether through browsers or * programmatically, you will need to ensure your client machines support any of * the following CAs:

  • Amazon Root CA 1

  • *

    Starfield Services Root Certificate Authority - G2

  • *

    Starfield Class 2 Certification Authority

Root * certificates from the first two authorities are available from Amazon trust services, but * keeping your computer up-to-date is the more straightforward solution. To learn * more about ACM-provided certificates, see Amazon Web * Services Certificate Manager FAQs.

*/ class AWS_LAMBDA_API LambdaClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); static const char* GetAllocationTag(); typedef LambdaClientConfiguration ClientConfigurationType; typedef LambdaEndpointProvider EndpointProviderType; /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ LambdaClient(const Aws::Lambda::LambdaClientConfiguration& clientConfiguration = Aws::Lambda::LambdaClientConfiguration(), std::shared_ptr endpointProvider = nullptr); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ LambdaClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr endpointProvider = nullptr, const Aws::Lambda::LambdaClientConfiguration& clientConfiguration = Aws::Lambda::LambdaClientConfiguration()); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ LambdaClient(const std::shared_ptr& credentialsProvider, std::shared_ptr endpointProvider = nullptr, const Aws::Lambda::LambdaClientConfiguration& clientConfiguration = Aws::Lambda::LambdaClientConfiguration()); /* Legacy constructors due deprecation */ /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ LambdaClient(const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ LambdaClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ LambdaClient(const std::shared_ptr& credentialsProvider, const Aws::Client::ClientConfiguration& clientConfiguration); /* End of legacy constructors due deprecation */ virtual ~LambdaClient(); /** *

Adds permissions to the resource-based policy of a version of an Lambda * layer. Use this action to grant layer usage permission to other accounts. * You can grant permission to a single account, all accounts in an organization, * or all Amazon Web Services accounts.

To revoke permission, call * RemoveLayerVersionPermission with the statement ID that you specified * when you added it.

See Also:

AWS * API Reference

*/ virtual Model::AddLayerVersionPermissionOutcome AddLayerVersionPermission(const Model::AddLayerVersionPermissionRequest& request) const; /** * A Callable wrapper for AddLayerVersionPermission that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AddLayerVersionPermissionOutcomeCallable AddLayerVersionPermissionCallable(const AddLayerVersionPermissionRequestT& request) const { return SubmitCallable(&LambdaClient::AddLayerVersionPermission, request); } /** * An Async wrapper for AddLayerVersionPermission that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AddLayerVersionPermissionAsync(const AddLayerVersionPermissionRequestT& request, const AddLayerVersionPermissionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::AddLayerVersionPermission, request, handler, context); } /** *

Grants a principal * permission to use a function. You can apply the policy at the function level, or * specify a qualifier to restrict access to a single version or alias. If you use * a qualifier, the invoker must use the full Amazon Resource Name (ARN) of that * version or alias to invoke the function. Note: Lambda does not support adding * policies to version $LATEST.

To grant permission to another account, * specify the account ID as the Principal. To grant permission to an * organization defined in Organizations, specify the organization ID as the * PrincipalOrgID. For Amazon Web Services services, the principal is * a domain-style identifier that the service defines, such as * s3.amazonaws.com or sns.amazonaws.com. For Amazon Web * Services services, you can also specify the ARN of the associated resource as * the SourceArn. If you grant permission to a service principal * without specifying the source, other accounts could potentially configure * resources in their account to invoke your Lambda function.

This operation * adds a statement to a resource-based permissions policy for the function. For * more information about function policies, see Using * resource-based policies for Lambda.

See Also:

AWS * API Reference

*/ virtual Model::AddPermissionOutcome AddPermission(const Model::AddPermissionRequest& request) const; /** * A Callable wrapper for AddPermission that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AddPermissionOutcomeCallable AddPermissionCallable(const AddPermissionRequestT& request) const { return SubmitCallable(&LambdaClient::AddPermission, request); } /** * An Async wrapper for AddPermission that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AddPermissionAsync(const AddPermissionRequestT& request, const AddPermissionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::AddPermission, request, handler, context); } /** *

Creates an alias * for a Lambda function version. Use aliases to provide clients with a function * identifier that you can update to invoke a different version.

You can * also map an alias to split invocation requests between two versions. Use the * RoutingConfig parameter to specify a second version and the * percentage of invocation requests that it receives.

See Also:

* AWS * API Reference

*/ virtual Model::CreateAliasOutcome CreateAlias(const Model::CreateAliasRequest& request) const; /** * A Callable wrapper for CreateAlias that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateAliasOutcomeCallable CreateAliasCallable(const CreateAliasRequestT& request) const { return SubmitCallable(&LambdaClient::CreateAlias, request); } /** * An Async wrapper for CreateAlias that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateAliasAsync(const CreateAliasRequestT& request, const CreateAliasResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::CreateAlias, request, handler, context); } /** *

Creates a code signing configuration. A code * signing configuration defines a list of allowed signing profiles and defines * the code-signing validation policy (action to be taken if deployment validation * checks fail).

See Also:

AWS * API Reference

*/ virtual Model::CreateCodeSigningConfigOutcome CreateCodeSigningConfig(const Model::CreateCodeSigningConfigRequest& request) const; /** * A Callable wrapper for CreateCodeSigningConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateCodeSigningConfigOutcomeCallable CreateCodeSigningConfigCallable(const CreateCodeSigningConfigRequestT& request) const { return SubmitCallable(&LambdaClient::CreateCodeSigningConfig, request); } /** * An Async wrapper for CreateCodeSigningConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateCodeSigningConfigAsync(const CreateCodeSigningConfigRequestT& request, const CreateCodeSigningConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::CreateCodeSigningConfig, request, handler, context); } /** *

Creates a mapping between an event source and an Lambda function. Lambda * reads items from the event source and invokes the function.

For details * about how to configure different event sources, see the following topics.

*

The following error handling options are * available only for DynamoDB and Kinesis event sources:

  • * BisectBatchOnFunctionError – If the function returns an error, * split the batch in two and retry.

  • * MaximumRecordAgeInSeconds – Discard records older than the * specified age. The default value is infinite (-1). When set to infinite (-1), * failed records are retried until the record expires

  • * MaximumRetryAttempts – Discard records after the specified number * of retries. The default value is infinite (-1). When set to infinite (-1), * failed records are retried until the record expires.

  • * ParallelizationFactor – Process multiple batches from each shard * concurrently.

For stream sources (DynamoDB, Kinesis, Amazon * MSK, and self-managed Apache Kafka), the following option is also available:

*

  • DestinationConfig – Send discarded records to an * Amazon SQS queue, Amazon SNS topic, or Amazon S3 bucket.

For * information about which configuration parameters apply to each event source, see * the following topics.

See Also:

AWS * API Reference

*/ virtual Model::CreateEventSourceMappingOutcome CreateEventSourceMapping(const Model::CreateEventSourceMappingRequest& request) const; /** * A Callable wrapper for CreateEventSourceMapping that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateEventSourceMappingOutcomeCallable CreateEventSourceMappingCallable(const CreateEventSourceMappingRequestT& request) const { return SubmitCallable(&LambdaClient::CreateEventSourceMapping, request); } /** * An Async wrapper for CreateEventSourceMapping that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateEventSourceMappingAsync(const CreateEventSourceMappingRequestT& request, const CreateEventSourceMappingResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::CreateEventSourceMapping, request, handler, context); } /** *

Creates a Lambda function. To create a function, you need a deployment * package and an execution * role. The deployment package is a .zip file archive or container image that * contains your function code. The execution role grants the function permission * to use Amazon Web Services services, such as Amazon CloudWatch Logs for log * streaming and X-Ray for request tracing.

If the deployment package is a * container * image, then you set the package type to Image. For a container * image, the code property must include the URI of a container image in the Amazon * ECR registry. You do not need to specify the handler and runtime properties.

*

If the deployment package is a .zip * file archive, then you set the package type to Zip. For a .zip * file archive, the code property specifies the location of the .zip file. You * must also specify the handler and runtime properties. The code in the deployment * package must be compatible with the target instruction set architecture of the * function (x86-64 or arm64). If you do not specify the * architecture, then the default value is x86-64.

When you * create a function, Lambda provisions an instance of the function and its * supporting resources. If your function connects to a VPC, this process can take * a minute or so. During this time, you can't invoke or modify the function. The * State, StateReason, and StateReasonCode * fields in the response from GetFunctionConfiguration indicate when the * function is ready to invoke. For more information, see Lambda * function states.

A function has an unpublished version, and can have * published versions and aliases. The unpublished version changes when you update * your function's code and configuration. A published version is a snapshot of * your function code and configuration that can't be changed. An alias is a named * resource that maps to a version, and can be changed to map to a different * version. Use the Publish parameter to create version 1 * of your function from its initial configuration.

The other parameters let * you configure version-specific and function-level settings. You can modify * version-specific settings later with UpdateFunctionConfiguration. * Function-level settings apply to both the unpublished and published versions of * the function, and include tags (TagResource) and per-function concurrency * limits (PutFunctionConcurrency).

You can use code signing if your * deployment package is a .zip file archive. To enable code signing for this * function, specify the ARN of a code-signing configuration. When a user attempts * to deploy a code package with UpdateFunctionCode, Lambda checks that the * code package has a valid signature from a trusted publisher. The code-signing * configuration includes set of signing profiles, which define the trusted * publishers for this function.

If another Amazon Web Services account or * an Amazon Web Services service invokes your function, use AddPermission * to grant permission by creating a resource-based Identity and Access Management * (IAM) policy. You can grant permissions at the function level, on a version, or * on an alias.

To invoke your function directly, use Invoke. To * invoke your function in response to events in other Amazon Web Services * services, create an event source mapping (CreateEventSourceMapping), or * configure a function trigger in the other service. For more information, see Invoking * Lambda functions.

See Also:

AWS * API Reference

*/ virtual Model::CreateFunctionOutcome CreateFunction(const Model::CreateFunctionRequest& request) const; /** * A Callable wrapper for CreateFunction that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateFunctionOutcomeCallable CreateFunctionCallable(const CreateFunctionRequestT& request) const { return SubmitCallable(&LambdaClient::CreateFunction, request); } /** * An Async wrapper for CreateFunction that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateFunctionAsync(const CreateFunctionRequestT& request, const CreateFunctionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::CreateFunction, request, handler, context); } /** *

Creates a Lambda function URL with the specified configuration parameters. A * function URL is a dedicated HTTP(S) endpoint that you can use to invoke your * function.

See Also:

AWS * API Reference

*/ virtual Model::CreateFunctionUrlConfigOutcome CreateFunctionUrlConfig(const Model::CreateFunctionUrlConfigRequest& request) const; /** * A Callable wrapper for CreateFunctionUrlConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateFunctionUrlConfigOutcomeCallable CreateFunctionUrlConfigCallable(const CreateFunctionUrlConfigRequestT& request) const { return SubmitCallable(&LambdaClient::CreateFunctionUrlConfig, request); } /** * An Async wrapper for CreateFunctionUrlConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateFunctionUrlConfigAsync(const CreateFunctionUrlConfigRequestT& request, const CreateFunctionUrlConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::CreateFunctionUrlConfig, request, handler, context); } /** *

Deletes a Lambda function alias.

See * Also:

AWS * API Reference

*/ virtual Model::DeleteAliasOutcome DeleteAlias(const Model::DeleteAliasRequest& request) const; /** * A Callable wrapper for DeleteAlias that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteAliasOutcomeCallable DeleteAliasCallable(const DeleteAliasRequestT& request) const { return SubmitCallable(&LambdaClient::DeleteAlias, request); } /** * An Async wrapper for DeleteAlias that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteAliasAsync(const DeleteAliasRequestT& request, const DeleteAliasResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::DeleteAlias, request, handler, context); } /** *

Deletes the code signing configuration. You can delete the code signing * configuration only if no function is using it.

See Also:

AWS * API Reference

*/ virtual Model::DeleteCodeSigningConfigOutcome DeleteCodeSigningConfig(const Model::DeleteCodeSigningConfigRequest& request) const; /** * A Callable wrapper for DeleteCodeSigningConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteCodeSigningConfigOutcomeCallable DeleteCodeSigningConfigCallable(const DeleteCodeSigningConfigRequestT& request) const { return SubmitCallable(&LambdaClient::DeleteCodeSigningConfig, request); } /** * An Async wrapper for DeleteCodeSigningConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteCodeSigningConfigAsync(const DeleteCodeSigningConfigRequestT& request, const DeleteCodeSigningConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::DeleteCodeSigningConfig, request, handler, context); } /** *

Deletes an event * source mapping. You can get the identifier of a mapping from the output of * ListEventSourceMappings.

When you delete an event source mapping, * it enters a Deleting state and might not be completely deleted for * several seconds.

See Also:

AWS * API Reference

*/ virtual Model::DeleteEventSourceMappingOutcome DeleteEventSourceMapping(const Model::DeleteEventSourceMappingRequest& request) const; /** * A Callable wrapper for DeleteEventSourceMapping that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteEventSourceMappingOutcomeCallable DeleteEventSourceMappingCallable(const DeleteEventSourceMappingRequestT& request) const { return SubmitCallable(&LambdaClient::DeleteEventSourceMapping, request); } /** * An Async wrapper for DeleteEventSourceMapping that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteEventSourceMappingAsync(const DeleteEventSourceMappingRequestT& request, const DeleteEventSourceMappingResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::DeleteEventSourceMapping, request, handler, context); } /** *

Deletes a Lambda function. To delete a specific function version, use the * Qualifier parameter. Otherwise, all versions and aliases are * deleted. This doesn't require the user to have explicit permissions for * DeleteAlias.

To delete Lambda event source mappings that invoke a * function, use DeleteEventSourceMapping. For Amazon Web Services services * and resources that invoke your function directly, delete the trigger in the * service where you originally configured it.

See Also:

AWS * API Reference

*/ virtual Model::DeleteFunctionOutcome DeleteFunction(const Model::DeleteFunctionRequest& request) const; /** * A Callable wrapper for DeleteFunction that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteFunctionOutcomeCallable DeleteFunctionCallable(const DeleteFunctionRequestT& request) const { return SubmitCallable(&LambdaClient::DeleteFunction, request); } /** * An Async wrapper for DeleteFunction that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteFunctionAsync(const DeleteFunctionRequestT& request, const DeleteFunctionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::DeleteFunction, request, handler, context); } /** *

Removes the code signing configuration from the function.

See * Also:

AWS * API Reference

*/ virtual Model::DeleteFunctionCodeSigningConfigOutcome DeleteFunctionCodeSigningConfig(const Model::DeleteFunctionCodeSigningConfigRequest& request) const; /** * A Callable wrapper for DeleteFunctionCodeSigningConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteFunctionCodeSigningConfigOutcomeCallable DeleteFunctionCodeSigningConfigCallable(const DeleteFunctionCodeSigningConfigRequestT& request) const { return SubmitCallable(&LambdaClient::DeleteFunctionCodeSigningConfig, request); } /** * An Async wrapper for DeleteFunctionCodeSigningConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteFunctionCodeSigningConfigAsync(const DeleteFunctionCodeSigningConfigRequestT& request, const DeleteFunctionCodeSigningConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::DeleteFunctionCodeSigningConfig, request, handler, context); } /** *

Removes a concurrent execution limit from a function.

See * Also:

AWS * API Reference

*/ virtual Model::DeleteFunctionConcurrencyOutcome DeleteFunctionConcurrency(const Model::DeleteFunctionConcurrencyRequest& request) const; /** * A Callable wrapper for DeleteFunctionConcurrency that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteFunctionConcurrencyOutcomeCallable DeleteFunctionConcurrencyCallable(const DeleteFunctionConcurrencyRequestT& request) const { return SubmitCallable(&LambdaClient::DeleteFunctionConcurrency, request); } /** * An Async wrapper for DeleteFunctionConcurrency that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteFunctionConcurrencyAsync(const DeleteFunctionConcurrencyRequestT& request, const DeleteFunctionConcurrencyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::DeleteFunctionConcurrency, request, handler, context); } /** *

Deletes the configuration for asynchronous invocation for a function, * version, or alias.

To configure options for asynchronous invocation, use * PutFunctionEventInvokeConfig.

See Also:

AWS * API Reference

*/ virtual Model::DeleteFunctionEventInvokeConfigOutcome DeleteFunctionEventInvokeConfig(const Model::DeleteFunctionEventInvokeConfigRequest& request) const; /** * A Callable wrapper for DeleteFunctionEventInvokeConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteFunctionEventInvokeConfigOutcomeCallable DeleteFunctionEventInvokeConfigCallable(const DeleteFunctionEventInvokeConfigRequestT& request) const { return SubmitCallable(&LambdaClient::DeleteFunctionEventInvokeConfig, request); } /** * An Async wrapper for DeleteFunctionEventInvokeConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteFunctionEventInvokeConfigAsync(const DeleteFunctionEventInvokeConfigRequestT& request, const DeleteFunctionEventInvokeConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::DeleteFunctionEventInvokeConfig, request, handler, context); } /** *

Deletes a Lambda function URL. When you delete a function URL, you can't * recover it. Creating a new function URL results in a different URL * address.

See Also:

AWS * API Reference

*/ virtual Model::DeleteFunctionUrlConfigOutcome DeleteFunctionUrlConfig(const Model::DeleteFunctionUrlConfigRequest& request) const; /** * A Callable wrapper for DeleteFunctionUrlConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteFunctionUrlConfigOutcomeCallable DeleteFunctionUrlConfigCallable(const DeleteFunctionUrlConfigRequestT& request) const { return SubmitCallable(&LambdaClient::DeleteFunctionUrlConfig, request); } /** * An Async wrapper for DeleteFunctionUrlConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteFunctionUrlConfigAsync(const DeleteFunctionUrlConfigRequestT& request, const DeleteFunctionUrlConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::DeleteFunctionUrlConfig, request, handler, context); } /** *

Deletes a version of an Lambda * layer. Deleted versions can no longer be viewed or added to functions. To * avoid breaking functions, a copy of the version remains in Lambda until no * functions refer to it.

See Also:

AWS * API Reference

*/ virtual Model::DeleteLayerVersionOutcome DeleteLayerVersion(const Model::DeleteLayerVersionRequest& request) const; /** * A Callable wrapper for DeleteLayerVersion that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteLayerVersionOutcomeCallable DeleteLayerVersionCallable(const DeleteLayerVersionRequestT& request) const { return SubmitCallable(&LambdaClient::DeleteLayerVersion, request); } /** * An Async wrapper for DeleteLayerVersion that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteLayerVersionAsync(const DeleteLayerVersionRequestT& request, const DeleteLayerVersionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::DeleteLayerVersion, request, handler, context); } /** *

Deletes the provisioned concurrency configuration for a * function.

See Also:

AWS * API Reference

*/ virtual Model::DeleteProvisionedConcurrencyConfigOutcome DeleteProvisionedConcurrencyConfig(const Model::DeleteProvisionedConcurrencyConfigRequest& request) const; /** * A Callable wrapper for DeleteProvisionedConcurrencyConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteProvisionedConcurrencyConfigOutcomeCallable DeleteProvisionedConcurrencyConfigCallable(const DeleteProvisionedConcurrencyConfigRequestT& request) const { return SubmitCallable(&LambdaClient::DeleteProvisionedConcurrencyConfig, request); } /** * An Async wrapper for DeleteProvisionedConcurrencyConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteProvisionedConcurrencyConfigAsync(const DeleteProvisionedConcurrencyConfigRequestT& request, const DeleteProvisionedConcurrencyConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::DeleteProvisionedConcurrencyConfig, request, handler, context); } /** *

Retrieves details about your account's limits and * usage in an Amazon Web Services Region.

See Also:

AWS * API Reference

*/ virtual Model::GetAccountSettingsOutcome GetAccountSettings(const Model::GetAccountSettingsRequest& request = {}) const; /** * A Callable wrapper for GetAccountSettings that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetAccountSettingsOutcomeCallable GetAccountSettingsCallable(const GetAccountSettingsRequestT& request = {}) const { return SubmitCallable(&LambdaClient::GetAccountSettings, request); } /** * An Async wrapper for GetAccountSettings that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetAccountSettingsAsync(const GetAccountSettingsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr, const GetAccountSettingsRequestT& request = {}) const { return SubmitAsync(&LambdaClient::GetAccountSettings, request, handler, context); } /** *

Returns details about a Lambda function alias.

See * Also:

AWS API * Reference

*/ virtual Model::GetAliasOutcome GetAlias(const Model::GetAliasRequest& request) const; /** * A Callable wrapper for GetAlias that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetAliasOutcomeCallable GetAliasCallable(const GetAliasRequestT& request) const { return SubmitCallable(&LambdaClient::GetAlias, request); } /** * An Async wrapper for GetAlias that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetAliasAsync(const GetAliasRequestT& request, const GetAliasResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::GetAlias, request, handler, context); } /** *

Returns information about the specified code signing * configuration.

See Also:

AWS * API Reference

*/ virtual Model::GetCodeSigningConfigOutcome GetCodeSigningConfig(const Model::GetCodeSigningConfigRequest& request) const; /** * A Callable wrapper for GetCodeSigningConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetCodeSigningConfigOutcomeCallable GetCodeSigningConfigCallable(const GetCodeSigningConfigRequestT& request) const { return SubmitCallable(&LambdaClient::GetCodeSigningConfig, request); } /** * An Async wrapper for GetCodeSigningConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetCodeSigningConfigAsync(const GetCodeSigningConfigRequestT& request, const GetCodeSigningConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::GetCodeSigningConfig, request, handler, context); } /** *

Returns details about an event source mapping. You can get the identifier of * a mapping from the output of ListEventSourceMappings.

See * Also:

AWS * API Reference

*/ virtual Model::GetEventSourceMappingOutcome GetEventSourceMapping(const Model::GetEventSourceMappingRequest& request) const; /** * A Callable wrapper for GetEventSourceMapping that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetEventSourceMappingOutcomeCallable GetEventSourceMappingCallable(const GetEventSourceMappingRequestT& request) const { return SubmitCallable(&LambdaClient::GetEventSourceMapping, request); } /** * An Async wrapper for GetEventSourceMapping that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetEventSourceMappingAsync(const GetEventSourceMappingRequestT& request, const GetEventSourceMappingResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::GetEventSourceMapping, request, handler, context); } /** *

Returns information about the function or function version, with a link to * download the deployment package that's valid for 10 minutes. If you specify a * function version, only details that are specific to that version are * returned.

See Also:

AWS * API Reference

*/ virtual Model::GetFunctionOutcome GetFunction(const Model::GetFunctionRequest& request) const; /** * A Callable wrapper for GetFunction that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetFunctionOutcomeCallable GetFunctionCallable(const GetFunctionRequestT& request) const { return SubmitCallable(&LambdaClient::GetFunction, request); } /** * An Async wrapper for GetFunction that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetFunctionAsync(const GetFunctionRequestT& request, const GetFunctionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::GetFunction, request, handler, context); } /** *

Returns the code signing configuration for the specified * function.

See Also:

AWS * API Reference

*/ virtual Model::GetFunctionCodeSigningConfigOutcome GetFunctionCodeSigningConfig(const Model::GetFunctionCodeSigningConfigRequest& request) const; /** * A Callable wrapper for GetFunctionCodeSigningConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetFunctionCodeSigningConfigOutcomeCallable GetFunctionCodeSigningConfigCallable(const GetFunctionCodeSigningConfigRequestT& request) const { return SubmitCallable(&LambdaClient::GetFunctionCodeSigningConfig, request); } /** * An Async wrapper for GetFunctionCodeSigningConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetFunctionCodeSigningConfigAsync(const GetFunctionCodeSigningConfigRequestT& request, const GetFunctionCodeSigningConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::GetFunctionCodeSigningConfig, request, handler, context); } /** *

Returns details about the reserved concurrency configuration for a function. * To set a concurrency limit for a function, use * PutFunctionConcurrency.

See Also:

AWS * API Reference

*/ virtual Model::GetFunctionConcurrencyOutcome GetFunctionConcurrency(const Model::GetFunctionConcurrencyRequest& request) const; /** * A Callable wrapper for GetFunctionConcurrency that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetFunctionConcurrencyOutcomeCallable GetFunctionConcurrencyCallable(const GetFunctionConcurrencyRequestT& request) const { return SubmitCallable(&LambdaClient::GetFunctionConcurrency, request); } /** * An Async wrapper for GetFunctionConcurrency that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetFunctionConcurrencyAsync(const GetFunctionConcurrencyRequestT& request, const GetFunctionConcurrencyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::GetFunctionConcurrency, request, handler, context); } /** *

Returns the version-specific settings of a Lambda function or version. The * output includes only options that can vary between versions of a function. To * modify these settings, use UpdateFunctionConfiguration.

To get all * of a function's details, including function-level settings, use * GetFunction.

See Also:

AWS * API Reference

*/ virtual Model::GetFunctionConfigurationOutcome GetFunctionConfiguration(const Model::GetFunctionConfigurationRequest& request) const; /** * A Callable wrapper for GetFunctionConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetFunctionConfigurationOutcomeCallable GetFunctionConfigurationCallable(const GetFunctionConfigurationRequestT& request) const { return SubmitCallable(&LambdaClient::GetFunctionConfiguration, request); } /** * An Async wrapper for GetFunctionConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetFunctionConfigurationAsync(const GetFunctionConfigurationRequestT& request, const GetFunctionConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::GetFunctionConfiguration, request, handler, context); } /** *

Retrieves the configuration for asynchronous invocation for a function, * version, or alias.

To configure options for asynchronous invocation, use * PutFunctionEventInvokeConfig.

See Also:

AWS * API Reference

*/ virtual Model::GetFunctionEventInvokeConfigOutcome GetFunctionEventInvokeConfig(const Model::GetFunctionEventInvokeConfigRequest& request) const; /** * A Callable wrapper for GetFunctionEventInvokeConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetFunctionEventInvokeConfigOutcomeCallable GetFunctionEventInvokeConfigCallable(const GetFunctionEventInvokeConfigRequestT& request) const { return SubmitCallable(&LambdaClient::GetFunctionEventInvokeConfig, request); } /** * An Async wrapper for GetFunctionEventInvokeConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetFunctionEventInvokeConfigAsync(const GetFunctionEventInvokeConfigRequestT& request, const GetFunctionEventInvokeConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::GetFunctionEventInvokeConfig, request, handler, context); } /** *

Returns your function's recursive * loop detection configuration.

See Also:

AWS * API Reference

*/ virtual Model::GetFunctionRecursionConfigOutcome GetFunctionRecursionConfig(const Model::GetFunctionRecursionConfigRequest& request) const; /** * A Callable wrapper for GetFunctionRecursionConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetFunctionRecursionConfigOutcomeCallable GetFunctionRecursionConfigCallable(const GetFunctionRecursionConfigRequestT& request) const { return SubmitCallable(&LambdaClient::GetFunctionRecursionConfig, request); } /** * An Async wrapper for GetFunctionRecursionConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetFunctionRecursionConfigAsync(const GetFunctionRecursionConfigRequestT& request, const GetFunctionRecursionConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::GetFunctionRecursionConfig, request, handler, context); } /** *

Returns details about a Lambda function URL.

See Also:

AWS * API Reference

*/ virtual Model::GetFunctionUrlConfigOutcome GetFunctionUrlConfig(const Model::GetFunctionUrlConfigRequest& request) const; /** * A Callable wrapper for GetFunctionUrlConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetFunctionUrlConfigOutcomeCallable GetFunctionUrlConfigCallable(const GetFunctionUrlConfigRequestT& request) const { return SubmitCallable(&LambdaClient::GetFunctionUrlConfig, request); } /** * An Async wrapper for GetFunctionUrlConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetFunctionUrlConfigAsync(const GetFunctionUrlConfigRequestT& request, const GetFunctionUrlConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::GetFunctionUrlConfig, request, handler, context); } /** *

Returns information about a version of an Lambda * layer, with a link to download the layer archive that's valid for 10 * minutes.

See Also:

AWS * API Reference

*/ virtual Model::GetLayerVersionOutcome GetLayerVersion(const Model::GetLayerVersionRequest& request) const; /** * A Callable wrapper for GetLayerVersion that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetLayerVersionOutcomeCallable GetLayerVersionCallable(const GetLayerVersionRequestT& request) const { return SubmitCallable(&LambdaClient::GetLayerVersion, request); } /** * An Async wrapper for GetLayerVersion that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetLayerVersionAsync(const GetLayerVersionRequestT& request, const GetLayerVersionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::GetLayerVersion, request, handler, context); } /** *

Returns information about a version of an Lambda * layer, with a link to download the layer archive that's valid for 10 * minutes.

See Also:

AWS * API Reference

*/ virtual Model::GetLayerVersionByArnOutcome GetLayerVersionByArn(const Model::GetLayerVersionByArnRequest& request) const; /** * A Callable wrapper for GetLayerVersionByArn that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetLayerVersionByArnOutcomeCallable GetLayerVersionByArnCallable(const GetLayerVersionByArnRequestT& request) const { return SubmitCallable(&LambdaClient::GetLayerVersionByArn, request); } /** * An Async wrapper for GetLayerVersionByArn that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetLayerVersionByArnAsync(const GetLayerVersionByArnRequestT& request, const GetLayerVersionByArnResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::GetLayerVersionByArn, request, handler, context); } /** *

Returns the permission policy for a version of an Lambda * layer. For more information, see * AddLayerVersionPermission.

See Also:

AWS * API Reference

*/ virtual Model::GetLayerVersionPolicyOutcome GetLayerVersionPolicy(const Model::GetLayerVersionPolicyRequest& request) const; /** * A Callable wrapper for GetLayerVersionPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetLayerVersionPolicyOutcomeCallable GetLayerVersionPolicyCallable(const GetLayerVersionPolicyRequestT& request) const { return SubmitCallable(&LambdaClient::GetLayerVersionPolicy, request); } /** * An Async wrapper for GetLayerVersionPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetLayerVersionPolicyAsync(const GetLayerVersionPolicyRequestT& request, const GetLayerVersionPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::GetLayerVersionPolicy, request, handler, context); } /** *

Returns the resource-based * IAM policy for a function, version, or alias.

See Also:

AWS * API Reference

*/ virtual Model::GetPolicyOutcome GetPolicy(const Model::GetPolicyRequest& request) const; /** * A Callable wrapper for GetPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetPolicyOutcomeCallable GetPolicyCallable(const GetPolicyRequestT& request) const { return SubmitCallable(&LambdaClient::GetPolicy, request); } /** * An Async wrapper for GetPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetPolicyAsync(const GetPolicyRequestT& request, const GetPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::GetPolicy, request, handler, context); } /** *

Retrieves the provisioned concurrency configuration for a function's alias or * version.

See Also:

AWS * API Reference

*/ virtual Model::GetProvisionedConcurrencyConfigOutcome GetProvisionedConcurrencyConfig(const Model::GetProvisionedConcurrencyConfigRequest& request) const; /** * A Callable wrapper for GetProvisionedConcurrencyConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetProvisionedConcurrencyConfigOutcomeCallable GetProvisionedConcurrencyConfigCallable(const GetProvisionedConcurrencyConfigRequestT& request) const { return SubmitCallable(&LambdaClient::GetProvisionedConcurrencyConfig, request); } /** * An Async wrapper for GetProvisionedConcurrencyConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetProvisionedConcurrencyConfigAsync(const GetProvisionedConcurrencyConfigRequestT& request, const GetProvisionedConcurrencyConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::GetProvisionedConcurrencyConfig, request, handler, context); } /** *

Retrieves the runtime management configuration for a function's version. If * the runtime update mode is Manual, this includes the ARN of the runtime * version and the runtime update mode. If the runtime update mode is Auto * or Function update, this includes the runtime update mode and * null is returned for the ARN. For more information, see Runtime * updates.

See Also:

AWS * API Reference

*/ virtual Model::GetRuntimeManagementConfigOutcome GetRuntimeManagementConfig(const Model::GetRuntimeManagementConfigRequest& request) const; /** * A Callable wrapper for GetRuntimeManagementConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetRuntimeManagementConfigOutcomeCallable GetRuntimeManagementConfigCallable(const GetRuntimeManagementConfigRequestT& request) const { return SubmitCallable(&LambdaClient::GetRuntimeManagementConfig, request); } /** * An Async wrapper for GetRuntimeManagementConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetRuntimeManagementConfigAsync(const GetRuntimeManagementConfigRequestT& request, const GetRuntimeManagementConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::GetRuntimeManagementConfig, request, handler, context); } /** *

Invokes a Lambda function. You can invoke a function synchronously (and wait * for the response), or asynchronously. By default, Lambda invokes your function * synchronously (i.e. theInvocationType is * RequestResponse). To invoke a function asynchronously, set * InvocationType to Event. Lambda passes the * ClientContext object to your function for synchronous invocations * only.

For synchronous * invocation, details about the function response, including errors, are * included in the response body and headers. For either invocation type, you can * find more information in the execution * log and trace.

*

When an error occurs, your function may be invoked multiple times. Retry * behavior varies by error type, client, event source, and invocation type. For * example, if you invoke a function asynchronously and it returns an error, Lambda * executes the function up to two more times. For more information, see Error * handling and automatic retries in Lambda.

For asynchronous * invocation, Lambda adds events to a queue before sending them to your * function. If your function does not have enough capacity to keep up with the * queue, events may be lost. Occasionally, your function may receive the same * event multiple times, even if no error occurs. To retain events that were not * processed, configure your function with a dead-letter * queue.

The status code in the API response doesn't reflect function * errors. Error codes are reserved for errors that prevent your function from * executing, such as permissions errors, quota * errors, or issues with your function's code and configuration. For example, * Lambda returns TooManyRequestsException if running the function * would cause you to exceed a concurrency limit at either the account level * (ConcurrentInvocationLimitExceeded) or function level * (ReservedFunctionConcurrentInvocationLimitExceeded).

For * functions with a long timeout, your client might disconnect during synchronous * invocation while it waits for a response. Configure your HTTP client, SDK, * firewall, proxy, or operating system to allow for long connections with timeout * or keep-alive settings.

This operation requires permission for the lambda:InvokeFunction * action. For details on how to set up permissions for cross-account invocations, * see Granting * function access to other accounts.

See Also:

AWS API * Reference

*/ virtual Model::InvokeOutcome Invoke(const Model::InvokeRequest& request) const; /** * A Callable wrapper for Invoke that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::InvokeOutcomeCallable InvokeCallable(const InvokeRequestT& request) const { return SubmitCallable(&LambdaClient::Invoke, request); } /** * An Async wrapper for Invoke that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void InvokeAsync(const InvokeRequestT& request, const InvokeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::Invoke, request, handler, context); } /** *

Configure your Lambda functions to stream response payloads back to clients. * For more information, see Configuring * a Lambda function to stream responses.

This operation requires * permission for the lambda:InvokeFunction * action. For details on how to set up permissions for cross-account invocations, * see Granting * function access to other accounts.

See Also:

AWS * API Reference

*/ virtual Model::InvokeWithResponseStreamOutcome InvokeWithResponseStream(Model::InvokeWithResponseStreamRequest& request) const; /** * A Callable wrapper for InvokeWithResponseStream that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::InvokeWithResponseStreamOutcomeCallable InvokeWithResponseStreamCallable(InvokeWithResponseStreamRequestT& request) const { return SubmitCallable(&LambdaClient::InvokeWithResponseStream, request); } /** * An Async wrapper for InvokeWithResponseStream that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void InvokeWithResponseStreamAsync(InvokeWithResponseStreamRequestT& request, const InvokeWithResponseStreamResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::InvokeWithResponseStream, request, handler, context); } /** *

Returns a list of aliases * for a Lambda function.

See Also:

AWS * API Reference

*/ virtual Model::ListAliasesOutcome ListAliases(const Model::ListAliasesRequest& request) const; /** * A Callable wrapper for ListAliases that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListAliasesOutcomeCallable ListAliasesCallable(const ListAliasesRequestT& request) const { return SubmitCallable(&LambdaClient::ListAliases, request); } /** * An Async wrapper for ListAliases that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListAliasesAsync(const ListAliasesRequestT& request, const ListAliasesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::ListAliases, request, handler, context); } /** *

Returns a list of code * signing configurations. A request returns up to 10,000 configurations per * call. You can use the MaxItems parameter to return fewer * configurations per call.

See Also:

AWS * API Reference

*/ virtual Model::ListCodeSigningConfigsOutcome ListCodeSigningConfigs(const Model::ListCodeSigningConfigsRequest& request = {}) const; /** * A Callable wrapper for ListCodeSigningConfigs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListCodeSigningConfigsOutcomeCallable ListCodeSigningConfigsCallable(const ListCodeSigningConfigsRequestT& request = {}) const { return SubmitCallable(&LambdaClient::ListCodeSigningConfigs, request); } /** * An Async wrapper for ListCodeSigningConfigs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListCodeSigningConfigsAsync(const ListCodeSigningConfigsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr, const ListCodeSigningConfigsRequestT& request = {}) const { return SubmitAsync(&LambdaClient::ListCodeSigningConfigs, request, handler, context); } /** *

Lists event source mappings. Specify an EventSourceArn to show * only event source mappings for a single event source.

See Also:

* AWS * API Reference

*/ virtual Model::ListEventSourceMappingsOutcome ListEventSourceMappings(const Model::ListEventSourceMappingsRequest& request = {}) const; /** * A Callable wrapper for ListEventSourceMappings that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListEventSourceMappingsOutcomeCallable ListEventSourceMappingsCallable(const ListEventSourceMappingsRequestT& request = {}) const { return SubmitCallable(&LambdaClient::ListEventSourceMappings, request); } /** * An Async wrapper for ListEventSourceMappings that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListEventSourceMappingsAsync(const ListEventSourceMappingsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr, const ListEventSourceMappingsRequestT& request = {}) const { return SubmitAsync(&LambdaClient::ListEventSourceMappings, request, handler, context); } /** *

Retrieves a list of configurations for asynchronous invocation for a * function.

To configure options for asynchronous invocation, use * PutFunctionEventInvokeConfig.

See Also:

AWS * API Reference

*/ virtual Model::ListFunctionEventInvokeConfigsOutcome ListFunctionEventInvokeConfigs(const Model::ListFunctionEventInvokeConfigsRequest& request) const; /** * A Callable wrapper for ListFunctionEventInvokeConfigs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListFunctionEventInvokeConfigsOutcomeCallable ListFunctionEventInvokeConfigsCallable(const ListFunctionEventInvokeConfigsRequestT& request) const { return SubmitCallable(&LambdaClient::ListFunctionEventInvokeConfigs, request); } /** * An Async wrapper for ListFunctionEventInvokeConfigs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListFunctionEventInvokeConfigsAsync(const ListFunctionEventInvokeConfigsRequestT& request, const ListFunctionEventInvokeConfigsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::ListFunctionEventInvokeConfigs, request, handler, context); } /** *

Returns a list of Lambda function URLs for the specified * function.

See Also:

AWS * API Reference

*/ virtual Model::ListFunctionUrlConfigsOutcome ListFunctionUrlConfigs(const Model::ListFunctionUrlConfigsRequest& request) const; /** * A Callable wrapper for ListFunctionUrlConfigs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListFunctionUrlConfigsOutcomeCallable ListFunctionUrlConfigsCallable(const ListFunctionUrlConfigsRequestT& request) const { return SubmitCallable(&LambdaClient::ListFunctionUrlConfigs, request); } /** * An Async wrapper for ListFunctionUrlConfigs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListFunctionUrlConfigsAsync(const ListFunctionUrlConfigsRequestT& request, const ListFunctionUrlConfigsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::ListFunctionUrlConfigs, request, handler, context); } /** *

Returns a list of Lambda functions, with the version-specific configuration * of each. Lambda returns up to 50 functions per call.

Set * FunctionVersion to ALL to include all published * versions of each function in addition to the unpublished version.

*

The ListFunctions operation returns a subset of the * FunctionConfiguration fields. To get the additional fields (State, * StateReasonCode, StateReason, LastUpdateStatus, LastUpdateStatusReason, * LastUpdateStatusReasonCode, RuntimeVersionConfig) for a function or version, use * GetFunction.

See Also:

AWS * API Reference

*/ virtual Model::ListFunctionsOutcome ListFunctions(const Model::ListFunctionsRequest& request = {}) const; /** * A Callable wrapper for ListFunctions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListFunctionsOutcomeCallable ListFunctionsCallable(const ListFunctionsRequestT& request = {}) const { return SubmitCallable(&LambdaClient::ListFunctions, request); } /** * An Async wrapper for ListFunctions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListFunctionsAsync(const ListFunctionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr, const ListFunctionsRequestT& request = {}) const { return SubmitAsync(&LambdaClient::ListFunctions, request, handler, context); } /** *

List the functions that use the specified code signing configuration. You can * use this method prior to deleting a code signing configuration, to verify that * no functions are using it.

See Also:

AWS * API Reference

*/ virtual Model::ListFunctionsByCodeSigningConfigOutcome ListFunctionsByCodeSigningConfig(const Model::ListFunctionsByCodeSigningConfigRequest& request) const; /** * A Callable wrapper for ListFunctionsByCodeSigningConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListFunctionsByCodeSigningConfigOutcomeCallable ListFunctionsByCodeSigningConfigCallable(const ListFunctionsByCodeSigningConfigRequestT& request) const { return SubmitCallable(&LambdaClient::ListFunctionsByCodeSigningConfig, request); } /** * An Async wrapper for ListFunctionsByCodeSigningConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListFunctionsByCodeSigningConfigAsync(const ListFunctionsByCodeSigningConfigRequestT& request, const ListFunctionsByCodeSigningConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::ListFunctionsByCodeSigningConfig, request, handler, context); } /** *

Lists the versions of an Lambda * layer. Versions that have been deleted aren't listed. Specify a runtime * identifier to list only versions that indicate that they're compatible with * that runtime. Specify a compatible architecture to include only layer versions * that are compatible with that architecture.

See Also:

AWS * API Reference

*/ virtual Model::ListLayerVersionsOutcome ListLayerVersions(const Model::ListLayerVersionsRequest& request) const; /** * A Callable wrapper for ListLayerVersions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListLayerVersionsOutcomeCallable ListLayerVersionsCallable(const ListLayerVersionsRequestT& request) const { return SubmitCallable(&LambdaClient::ListLayerVersions, request); } /** * An Async wrapper for ListLayerVersions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListLayerVersionsAsync(const ListLayerVersionsRequestT& request, const ListLayerVersionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::ListLayerVersions, request, handler, context); } /** *

Lists Lambda * layers and shows information about the latest version of each. Specify a runtime * identifier to list only layers that indicate that they're compatible with * that runtime. Specify a compatible architecture to include only layers that are * compatible with that instruction * set architecture.

See Also:

AWS * API Reference

*/ virtual Model::ListLayersOutcome ListLayers(const Model::ListLayersRequest& request = {}) const; /** * A Callable wrapper for ListLayers that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListLayersOutcomeCallable ListLayersCallable(const ListLayersRequestT& request = {}) const { return SubmitCallable(&LambdaClient::ListLayers, request); } /** * An Async wrapper for ListLayers that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListLayersAsync(const ListLayersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr, const ListLayersRequestT& request = {}) const { return SubmitAsync(&LambdaClient::ListLayers, request, handler, context); } /** *

Retrieves a list of provisioned concurrency configurations for a * function.

See Also:

AWS * API Reference

*/ virtual Model::ListProvisionedConcurrencyConfigsOutcome ListProvisionedConcurrencyConfigs(const Model::ListProvisionedConcurrencyConfigsRequest& request) const; /** * A Callable wrapper for ListProvisionedConcurrencyConfigs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListProvisionedConcurrencyConfigsOutcomeCallable ListProvisionedConcurrencyConfigsCallable(const ListProvisionedConcurrencyConfigsRequestT& request) const { return SubmitCallable(&LambdaClient::ListProvisionedConcurrencyConfigs, request); } /** * An Async wrapper for ListProvisionedConcurrencyConfigs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListProvisionedConcurrencyConfigsAsync(const ListProvisionedConcurrencyConfigsRequestT& request, const ListProvisionedConcurrencyConfigsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::ListProvisionedConcurrencyConfigs, request, handler, context); } /** *

Returns a function, event source mapping, or code signing configuration's tags. You * can also view function tags with GetFunction.

See Also:

* AWS * API Reference

*/ virtual Model::ListTagsOutcome ListTags(const Model::ListTagsRequest& request) const; /** * A Callable wrapper for ListTags that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTagsOutcomeCallable ListTagsCallable(const ListTagsRequestT& request) const { return SubmitCallable(&LambdaClient::ListTags, request); } /** * An Async wrapper for ListTags that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTagsAsync(const ListTagsRequestT& request, const ListTagsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::ListTags, request, handler, context); } /** *

Returns a list of versions, * with the version-specific configuration of each. Lambda returns up to 50 * versions per call.

See Also:

AWS * API Reference

*/ virtual Model::ListVersionsByFunctionOutcome ListVersionsByFunction(const Model::ListVersionsByFunctionRequest& request) const; /** * A Callable wrapper for ListVersionsByFunction that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListVersionsByFunctionOutcomeCallable ListVersionsByFunctionCallable(const ListVersionsByFunctionRequestT& request) const { return SubmitCallable(&LambdaClient::ListVersionsByFunction, request); } /** * An Async wrapper for ListVersionsByFunction that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListVersionsByFunctionAsync(const ListVersionsByFunctionRequestT& request, const ListVersionsByFunctionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::ListVersionsByFunction, request, handler, context); } /** *

Creates an Lambda * layer from a ZIP archive. Each time you call * PublishLayerVersion with the same layer name, a new version is * created.

Add layers to your function with CreateFunction or * UpdateFunctionConfiguration.

See Also:

AWS * API Reference

*/ virtual Model::PublishLayerVersionOutcome PublishLayerVersion(const Model::PublishLayerVersionRequest& request) const; /** * A Callable wrapper for PublishLayerVersion that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PublishLayerVersionOutcomeCallable PublishLayerVersionCallable(const PublishLayerVersionRequestT& request) const { return SubmitCallable(&LambdaClient::PublishLayerVersion, request); } /** * An Async wrapper for PublishLayerVersion that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PublishLayerVersionAsync(const PublishLayerVersionRequestT& request, const PublishLayerVersionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::PublishLayerVersion, request, handler, context); } /** *

Creates a version * from the current code and configuration of a function. Use versions to create a * snapshot of your function code and configuration that doesn't change.

*

Lambda doesn't publish a version if the function's configuration and code * haven't changed since the last version. Use UpdateFunctionCode or * UpdateFunctionConfiguration to update the function before publishing a * version.

Clients can invoke versions directly or with an alias. To create * an alias, use CreateAlias.

See Also:

AWS * API Reference

*/ virtual Model::PublishVersionOutcome PublishVersion(const Model::PublishVersionRequest& request) const; /** * A Callable wrapper for PublishVersion that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PublishVersionOutcomeCallable PublishVersionCallable(const PublishVersionRequestT& request) const { return SubmitCallable(&LambdaClient::PublishVersion, request); } /** * An Async wrapper for PublishVersion that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PublishVersionAsync(const PublishVersionRequestT& request, const PublishVersionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::PublishVersion, request, handler, context); } /** *

Update the code signing configuration for the function. Changes to the code * signing configuration take effect the next time a user tries to deploy a code * package to the function.

See Also:

AWS * API Reference

*/ virtual Model::PutFunctionCodeSigningConfigOutcome PutFunctionCodeSigningConfig(const Model::PutFunctionCodeSigningConfigRequest& request) const; /** * A Callable wrapper for PutFunctionCodeSigningConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutFunctionCodeSigningConfigOutcomeCallable PutFunctionCodeSigningConfigCallable(const PutFunctionCodeSigningConfigRequestT& request) const { return SubmitCallable(&LambdaClient::PutFunctionCodeSigningConfig, request); } /** * An Async wrapper for PutFunctionCodeSigningConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutFunctionCodeSigningConfigAsync(const PutFunctionCodeSigningConfigRequestT& request, const PutFunctionCodeSigningConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::PutFunctionCodeSigningConfig, request, handler, context); } /** *

Sets the maximum number of simultaneous executions for a function, and * reserves capacity for that concurrency level.

Concurrency settings apply * to the function as a whole, including all published versions and the unpublished * version. Reserving concurrency both ensures that your function has capacity to * process the specified number of events simultaneously, and prevents it from * scaling beyond that level. Use GetFunction to see the current setting for * a function.

Use GetAccountSettings to see your Regional * concurrency limit. You can reserve concurrency for as many functions as you * like, as long as you leave at least 100 simultaneous executions unreserved for * functions that aren't configured with a per-function limit. For more * information, see Lambda * function scaling.

See Also:

AWS * API Reference

*/ virtual Model::PutFunctionConcurrencyOutcome PutFunctionConcurrency(const Model::PutFunctionConcurrencyRequest& request) const; /** * A Callable wrapper for PutFunctionConcurrency that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutFunctionConcurrencyOutcomeCallable PutFunctionConcurrencyCallable(const PutFunctionConcurrencyRequestT& request) const { return SubmitCallable(&LambdaClient::PutFunctionConcurrency, request); } /** * An Async wrapper for PutFunctionConcurrency that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutFunctionConcurrencyAsync(const PutFunctionConcurrencyRequestT& request, const PutFunctionConcurrencyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::PutFunctionConcurrency, request, handler, context); } /** *

Configures options for asynchronous * invocation on a function, version, or alias. If a configuration already * exists for a function, version, or alias, this operation overwrites it. If you * exclude any settings, they are removed. To set one option without affecting * existing settings for other options, use * UpdateFunctionEventInvokeConfig.

By default, Lambda retries an * asynchronous invocation twice if the function returns an error. It retains * events in a queue for up to six hours. When an event fails all processing * attempts or stays in the asynchronous invocation queue for too long, Lambda * discards it. To retain discarded events, configure a dead-letter queue with * UpdateFunctionConfiguration.

To send an invocation record to a * queue, topic, S3 bucket, function, or event bus, specify a destination. * You can configure separate destinations for successful invocations (on-success) * and events that fail all processing attempts (on-failure). You can configure * destinations in addition to or instead of a dead-letter queue.

S3 * buckets are supported only for on-failure destinations. To retain records of * successful invocations, use another destination type.

See * Also:

AWS * API Reference

*/ virtual Model::PutFunctionEventInvokeConfigOutcome PutFunctionEventInvokeConfig(const Model::PutFunctionEventInvokeConfigRequest& request) const; /** * A Callable wrapper for PutFunctionEventInvokeConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutFunctionEventInvokeConfigOutcomeCallable PutFunctionEventInvokeConfigCallable(const PutFunctionEventInvokeConfigRequestT& request) const { return SubmitCallable(&LambdaClient::PutFunctionEventInvokeConfig, request); } /** * An Async wrapper for PutFunctionEventInvokeConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutFunctionEventInvokeConfigAsync(const PutFunctionEventInvokeConfigRequestT& request, const PutFunctionEventInvokeConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::PutFunctionEventInvokeConfig, request, handler, context); } /** *

Sets your function's recursive * loop detection configuration.

When you configure a Lambda function to * output to the same service or resource that invokes the function, it's possible * to create an infinite recursive loop. For example, a Lambda function might write * a message to an Amazon Simple Queue Service (Amazon SQS) queue, which then * invokes the same function. This invocation causes the function to write another * message to the queue, which in turn invokes the function again.

Lambda * can detect certain types of recursive loops shortly after they occur. When * Lambda detects a recursive loop and your function's recursive loop detection * configuration is set to Terminate, it stops your function being * invoked and notifies you.

See Also:

AWS * API Reference

*/ virtual Model::PutFunctionRecursionConfigOutcome PutFunctionRecursionConfig(const Model::PutFunctionRecursionConfigRequest& request) const; /** * A Callable wrapper for PutFunctionRecursionConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutFunctionRecursionConfigOutcomeCallable PutFunctionRecursionConfigCallable(const PutFunctionRecursionConfigRequestT& request) const { return SubmitCallable(&LambdaClient::PutFunctionRecursionConfig, request); } /** * An Async wrapper for PutFunctionRecursionConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutFunctionRecursionConfigAsync(const PutFunctionRecursionConfigRequestT& request, const PutFunctionRecursionConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::PutFunctionRecursionConfig, request, handler, context); } /** *

Adds a provisioned concurrency configuration to a function's alias or * version.

See Also:

AWS * API Reference

*/ virtual Model::PutProvisionedConcurrencyConfigOutcome PutProvisionedConcurrencyConfig(const Model::PutProvisionedConcurrencyConfigRequest& request) const; /** * A Callable wrapper for PutProvisionedConcurrencyConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutProvisionedConcurrencyConfigOutcomeCallable PutProvisionedConcurrencyConfigCallable(const PutProvisionedConcurrencyConfigRequestT& request) const { return SubmitCallable(&LambdaClient::PutProvisionedConcurrencyConfig, request); } /** * An Async wrapper for PutProvisionedConcurrencyConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutProvisionedConcurrencyConfigAsync(const PutProvisionedConcurrencyConfigRequestT& request, const PutProvisionedConcurrencyConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::PutProvisionedConcurrencyConfig, request, handler, context); } /** *

Sets the runtime management configuration for a function's version. For more * information, see Runtime * updates.

See Also:

AWS * API Reference

*/ virtual Model::PutRuntimeManagementConfigOutcome PutRuntimeManagementConfig(const Model::PutRuntimeManagementConfigRequest& request) const; /** * A Callable wrapper for PutRuntimeManagementConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutRuntimeManagementConfigOutcomeCallable PutRuntimeManagementConfigCallable(const PutRuntimeManagementConfigRequestT& request) const { return SubmitCallable(&LambdaClient::PutRuntimeManagementConfig, request); } /** * An Async wrapper for PutRuntimeManagementConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutRuntimeManagementConfigAsync(const PutRuntimeManagementConfigRequestT& request, const PutRuntimeManagementConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::PutRuntimeManagementConfig, request, handler, context); } /** *

Removes a statement from the permissions policy for a version of an Lambda * layer. For more information, see * AddLayerVersionPermission.

See Also:

AWS * API Reference

*/ virtual Model::RemoveLayerVersionPermissionOutcome RemoveLayerVersionPermission(const Model::RemoveLayerVersionPermissionRequest& request) const; /** * A Callable wrapper for RemoveLayerVersionPermission that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RemoveLayerVersionPermissionOutcomeCallable RemoveLayerVersionPermissionCallable(const RemoveLayerVersionPermissionRequestT& request) const { return SubmitCallable(&LambdaClient::RemoveLayerVersionPermission, request); } /** * An Async wrapper for RemoveLayerVersionPermission that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RemoveLayerVersionPermissionAsync(const RemoveLayerVersionPermissionRequestT& request, const RemoveLayerVersionPermissionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::RemoveLayerVersionPermission, request, handler, context); } /** *

Revokes function-use permission from an Amazon Web Services service or * another Amazon Web Services account. You can get the ID of the statement from * the output of GetPolicy.

See Also:

AWS * API Reference

*/ virtual Model::RemovePermissionOutcome RemovePermission(const Model::RemovePermissionRequest& request) const; /** * A Callable wrapper for RemovePermission that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RemovePermissionOutcomeCallable RemovePermissionCallable(const RemovePermissionRequestT& request) const { return SubmitCallable(&LambdaClient::RemovePermission, request); } /** * An Async wrapper for RemovePermission that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RemovePermissionAsync(const RemovePermissionRequestT& request, const RemovePermissionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::RemovePermission, request, handler, context); } /** *

Adds tags to a * function, event source mapping, or code signing configuration.

See * Also:

AWS * API Reference

*/ virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const; /** * A Callable wrapper for TagResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const { return SubmitCallable(&LambdaClient::TagResource, request); } /** * An Async wrapper for TagResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::TagResource, request, handler, context); } /** *

Removes tags from a * function, event source mapping, or code signing configuration.

See * Also:

AWS * API Reference

*/ virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const; /** * A Callable wrapper for UntagResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const { return SubmitCallable(&LambdaClient::UntagResource, request); } /** * An Async wrapper for UntagResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::UntagResource, request, handler, context); } /** *

Updates the configuration of a Lambda function alias.

See * Also:

AWS * API Reference

*/ virtual Model::UpdateAliasOutcome UpdateAlias(const Model::UpdateAliasRequest& request) const; /** * A Callable wrapper for UpdateAlias that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateAliasOutcomeCallable UpdateAliasCallable(const UpdateAliasRequestT& request) const { return SubmitCallable(&LambdaClient::UpdateAlias, request); } /** * An Async wrapper for UpdateAlias that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateAliasAsync(const UpdateAliasRequestT& request, const UpdateAliasResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::UpdateAlias, request, handler, context); } /** *

Update the code signing configuration. Changes to the code signing * configuration take effect the next time a user tries to deploy a code package to * the function.

See Also:

AWS * API Reference

*/ virtual Model::UpdateCodeSigningConfigOutcome UpdateCodeSigningConfig(const Model::UpdateCodeSigningConfigRequest& request) const; /** * A Callable wrapper for UpdateCodeSigningConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateCodeSigningConfigOutcomeCallable UpdateCodeSigningConfigCallable(const UpdateCodeSigningConfigRequestT& request) const { return SubmitCallable(&LambdaClient::UpdateCodeSigningConfig, request); } /** * An Async wrapper for UpdateCodeSigningConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateCodeSigningConfigAsync(const UpdateCodeSigningConfigRequestT& request, const UpdateCodeSigningConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::UpdateCodeSigningConfig, request, handler, context); } /** *

Updates an event source mapping. You can change the function that Lambda * invokes, or pause invocation and resume later from the same location.

For * details about how to configure different event sources, see the following * topics.

The following error handling options are * available only for DynamoDB and Kinesis event sources:

  • * BisectBatchOnFunctionError – If the function returns an error, * split the batch in two and retry.

  • * MaximumRecordAgeInSeconds – Discard records older than the * specified age. The default value is infinite (-1). When set to infinite (-1), * failed records are retried until the record expires

  • * MaximumRetryAttempts – Discard records after the specified number * of retries. The default value is infinite (-1). When set to infinite (-1), * failed records are retried until the record expires.

  • * ParallelizationFactor – Process multiple batches from each shard * concurrently.

For stream sources (DynamoDB, Kinesis, Amazon * MSK, and self-managed Apache Kafka), the following option is also available:

*

  • DestinationConfig – Send discarded records to an * Amazon SQS queue, Amazon SNS topic, or Amazon S3 bucket.

For * information about which configuration parameters apply to each event source, see * the following topics.

See Also:

AWS * API Reference

*/ virtual Model::UpdateEventSourceMappingOutcome UpdateEventSourceMapping(const Model::UpdateEventSourceMappingRequest& request) const; /** * A Callable wrapper for UpdateEventSourceMapping that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateEventSourceMappingOutcomeCallable UpdateEventSourceMappingCallable(const UpdateEventSourceMappingRequestT& request) const { return SubmitCallable(&LambdaClient::UpdateEventSourceMapping, request); } /** * An Async wrapper for UpdateEventSourceMapping that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateEventSourceMappingAsync(const UpdateEventSourceMappingRequestT& request, const UpdateEventSourceMappingResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::UpdateEventSourceMapping, request, handler, context); } /** *

Updates a Lambda function's code. If code signing is enabled for the * function, the code package must be signed by a trusted publisher. For more * information, see Configuring * code signing for Lambda.

If the function's package type is * Image, then you must specify the code package in * ImageUri as the URI of a container * image in the Amazon ECR registry.

If the function's package type is * Zip, then you must specify the deployment package as a .zip * file archive. Enter the Amazon S3 bucket and key of the code .zip file * location. You can also provide the function code inline using the * ZipFile field.

The code in the deployment package must be * compatible with the target instruction set architecture of the function * (x86-64 or arm64).

The function's code is * locked when you publish a version. You can't modify the code of a published * version, only the unpublished version.

For a function defined as a * container image, Lambda resolves the image tag to an image digest. In Amazon * ECR, if you update the image tag to a new image, Lambda does not automatically * update the function.

See Also:

AWS * API Reference

*/ virtual Model::UpdateFunctionCodeOutcome UpdateFunctionCode(const Model::UpdateFunctionCodeRequest& request) const; /** * A Callable wrapper for UpdateFunctionCode that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateFunctionCodeOutcomeCallable UpdateFunctionCodeCallable(const UpdateFunctionCodeRequestT& request) const { return SubmitCallable(&LambdaClient::UpdateFunctionCode, request); } /** * An Async wrapper for UpdateFunctionCode that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateFunctionCodeAsync(const UpdateFunctionCodeRequestT& request, const UpdateFunctionCodeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::UpdateFunctionCode, request, handler, context); } /** *

Modify the version-specific settings of a Lambda function.

When you * update a function, Lambda provisions an instance of the function and its * supporting resources. If your function connects to a VPC, this process can take * a minute. During this time, you can't modify the function, but you can still * invoke it. The LastUpdateStatus, * LastUpdateStatusReason, and LastUpdateStatusReasonCode * fields in the response from GetFunctionConfiguration indicate when the * update is complete and the function is processing events with the new * configuration. For more information, see Lambda * function states.

These settings can vary between versions of a * function and are locked when you publish a version. You can't modify the * configuration of a published version, only the unpublished version.

To * configure function concurrency, use PutFunctionConcurrency. To grant * invoke permissions to an Amazon Web Services account or Amazon Web Services * service, use AddPermission.

See Also:

AWS * API Reference

*/ virtual Model::UpdateFunctionConfigurationOutcome UpdateFunctionConfiguration(const Model::UpdateFunctionConfigurationRequest& request) const; /** * A Callable wrapper for UpdateFunctionConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateFunctionConfigurationOutcomeCallable UpdateFunctionConfigurationCallable(const UpdateFunctionConfigurationRequestT& request) const { return SubmitCallable(&LambdaClient::UpdateFunctionConfiguration, request); } /** * An Async wrapper for UpdateFunctionConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateFunctionConfigurationAsync(const UpdateFunctionConfigurationRequestT& request, const UpdateFunctionConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::UpdateFunctionConfiguration, request, handler, context); } /** *

Updates the configuration for asynchronous invocation for a function, * version, or alias.

To configure options for asynchronous invocation, use * PutFunctionEventInvokeConfig.

See Also:

AWS * API Reference

*/ virtual Model::UpdateFunctionEventInvokeConfigOutcome UpdateFunctionEventInvokeConfig(const Model::UpdateFunctionEventInvokeConfigRequest& request) const; /** * A Callable wrapper for UpdateFunctionEventInvokeConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateFunctionEventInvokeConfigOutcomeCallable UpdateFunctionEventInvokeConfigCallable(const UpdateFunctionEventInvokeConfigRequestT& request) const { return SubmitCallable(&LambdaClient::UpdateFunctionEventInvokeConfig, request); } /** * An Async wrapper for UpdateFunctionEventInvokeConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateFunctionEventInvokeConfigAsync(const UpdateFunctionEventInvokeConfigRequestT& request, const UpdateFunctionEventInvokeConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::UpdateFunctionEventInvokeConfig, request, handler, context); } /** *

Updates the configuration for a Lambda function URL.

See Also:

* AWS * API Reference

*/ virtual Model::UpdateFunctionUrlConfigOutcome UpdateFunctionUrlConfig(const Model::UpdateFunctionUrlConfigRequest& request) const; /** * A Callable wrapper for UpdateFunctionUrlConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateFunctionUrlConfigOutcomeCallable UpdateFunctionUrlConfigCallable(const UpdateFunctionUrlConfigRequestT& request) const { return SubmitCallable(&LambdaClient::UpdateFunctionUrlConfig, request); } /** * An Async wrapper for UpdateFunctionUrlConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateFunctionUrlConfigAsync(const UpdateFunctionUrlConfigRequestT& request, const UpdateFunctionUrlConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&LambdaClient::UpdateFunctionUrlConfig, request, handler, context); } void OverrideEndpoint(const Aws::String& endpoint); std::shared_ptr& accessEndpointProvider(); private: friend class Aws::Client::ClientWithAsyncTemplateMethods; void init(const LambdaClientConfiguration& clientConfiguration); LambdaClientConfiguration m_clientConfiguration; std::shared_ptr m_endpointProvider; }; } // namespace Lambda } // namespace Aws