@aws-sdk/client-lambda 3.36.0 → 3.39.0

package/dist-types/ts3.4/commands/PutFunctionConcurrencyCommand.d.ts

@@ -6,37 +6,11 @@ export interface PutFunctionConcurrencyCommandInput extends PutFunctionConcurren
 }
 export interface PutFunctionConcurrencyCommandOutput extends Concurrency, __MetadataBearer {
 }
-/**
- * <p>Sets the maximum number of simultaneous executions for a function, and reserves capacity for that concurrency
- *       level.</p>
- *          <p>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 <a>GetFunction</a> to see
- *       the current setting for a function.</p>
- *          <p>Use <a>GetAccountSettings</a> 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 <a href="https://docs.aws.amazon.com/lambda/latest/dg/concurrent-executions.html">Managing Concurrency</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LambdaClient, PutFunctionConcurrencyCommand } from "@aws-sdk/client-lambda"; // ES Modules import
- * // const { LambdaClient, PutFunctionConcurrencyCommand } = require("@aws-sdk/client-lambda"); // CommonJS import
- * const client = new LambdaClient(config);
- * const command = new PutFunctionConcurrencyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutFunctionConcurrencyCommandInput} for command's `input` shape.
- * @see {@link PutFunctionConcurrencyCommandOutput} for command's `response` shape.
- * @see {@link LambdaClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutFunctionConcurrencyCommand extends $Command<PutFunctionConcurrencyCommandInput, PutFunctionConcurrencyCommandOutput, LambdaClientResolvedConfig> {
     readonly input: PutFunctionConcurrencyCommandInput;
     constructor(input: PutFunctionConcurrencyCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutFunctionConcurrencyCommandInput, PutFunctionConcurrencyCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/PutFunctionEventInvokeConfigCommand.d.ts

@@ -6,39 +6,11 @@ export interface PutFunctionEventInvokeConfigCommandInput extends PutFunctionEve
 }
 export interface PutFunctionEventInvokeConfigCommandOutput extends FunctionEventInvokeConfig, __MetadataBearer {
 }
-/**
- * <p>Configures options for <a href="https://docs.aws.amazon.com/lambda/latest/dg/invocation-async.html">asynchronous
- *         invocation</a> 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 <a>UpdateFunctionEventInvokeConfig</a>.</p>
- *          <p>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
- *         <a>UpdateFunctionConfiguration</a>.</p>
- *          <p>To send an invocation record to a queue, topic, function, or event bus, specify a <a href="https://docs.aws.amazon.com/lambda/latest/dg/invocation-async.html#invocation-async-destinations">destination</a>. 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.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LambdaClient, PutFunctionEventInvokeConfigCommand } from "@aws-sdk/client-lambda"; // ES Modules import
- * // const { LambdaClient, PutFunctionEventInvokeConfigCommand } = require("@aws-sdk/client-lambda"); // CommonJS import
- * const client = new LambdaClient(config);
- * const command = new PutFunctionEventInvokeConfigCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutFunctionEventInvokeConfigCommandInput} for command's `input` shape.
- * @see {@link PutFunctionEventInvokeConfigCommandOutput} for command's `response` shape.
- * @see {@link LambdaClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutFunctionEventInvokeConfigCommand extends $Command<PutFunctionEventInvokeConfigCommandInput, PutFunctionEventInvokeConfigCommandOutput, LambdaClientResolvedConfig> {
     readonly input: PutFunctionEventInvokeConfigCommandInput;
     constructor(input: PutFunctionEventInvokeConfigCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutFunctionEventInvokeConfigCommandInput, PutFunctionEventInvokeConfigCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/PutProvisionedConcurrencyConfigCommand.d.ts

@@ -6,29 +6,11 @@ export interface PutProvisionedConcurrencyConfigCommandInput extends PutProvisio
 }
 export interface PutProvisionedConcurrencyConfigCommandOutput extends PutProvisionedConcurrencyConfigResponse, __MetadataBearer {
 }
-/**
- * <p>Adds a provisioned concurrency configuration to a function's alias or version.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LambdaClient, PutProvisionedConcurrencyConfigCommand } from "@aws-sdk/client-lambda"; // ES Modules import
- * // const { LambdaClient, PutProvisionedConcurrencyConfigCommand } = require("@aws-sdk/client-lambda"); // CommonJS import
- * const client = new LambdaClient(config);
- * const command = new PutProvisionedConcurrencyConfigCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutProvisionedConcurrencyConfigCommandInput} for command's `input` shape.
- * @see {@link PutProvisionedConcurrencyConfigCommandOutput} for command's `response` shape.
- * @see {@link LambdaClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutProvisionedConcurrencyConfigCommand extends $Command<PutProvisionedConcurrencyConfigCommandInput, PutProvisionedConcurrencyConfigCommandOutput, LambdaClientResolvedConfig> {
     readonly input: PutProvisionedConcurrencyConfigCommandInput;
     constructor(input: PutProvisionedConcurrencyConfigCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutProvisionedConcurrencyConfigCommandInput, PutProvisionedConcurrencyConfigCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/RemoveLayerVersionPermissionCommand.d.ts

@@ -6,31 +6,11 @@ export interface RemoveLayerVersionPermissionCommandInput extends RemoveLayerVer
 }
 export interface RemoveLayerVersionPermissionCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Removes a statement from the permissions policy for a version of an <a href="https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html">Lambda
- *         layer</a>. For more information, see
- *         <a>AddLayerVersionPermission</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LambdaClient, RemoveLayerVersionPermissionCommand } from "@aws-sdk/client-lambda"; // ES Modules import
- * // const { LambdaClient, RemoveLayerVersionPermissionCommand } = require("@aws-sdk/client-lambda"); // CommonJS import
- * const client = new LambdaClient(config);
- * const command = new RemoveLayerVersionPermissionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link RemoveLayerVersionPermissionCommandInput} for command's `input` shape.
- * @see {@link RemoveLayerVersionPermissionCommandOutput} for command's `response` shape.
- * @see {@link LambdaClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class RemoveLayerVersionPermissionCommand extends $Command<RemoveLayerVersionPermissionCommandInput, RemoveLayerVersionPermissionCommandOutput, LambdaClientResolvedConfig> {
     readonly input: RemoveLayerVersionPermissionCommandInput;
     constructor(input: RemoveLayerVersionPermissionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RemoveLayerVersionPermissionCommandInput, RemoveLayerVersionPermissionCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/RemovePermissionCommand.d.ts

@@ -6,30 +6,11 @@ export interface RemovePermissionCommandInput extends RemovePermissionRequest {
 }
 export interface RemovePermissionCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Revokes function-use permission from an Amazon Web Services service or another account. You can get the ID of the statement
- *       from the output of <a>GetPolicy</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LambdaClient, RemovePermissionCommand } from "@aws-sdk/client-lambda"; // ES Modules import
- * // const { LambdaClient, RemovePermissionCommand } = require("@aws-sdk/client-lambda"); // CommonJS import
- * const client = new LambdaClient(config);
- * const command = new RemovePermissionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link RemovePermissionCommandInput} for command's `input` shape.
- * @see {@link RemovePermissionCommandOutput} for command's `response` shape.
- * @see {@link LambdaClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class RemovePermissionCommand extends $Command<RemovePermissionCommandInput, RemovePermissionCommandOutput, LambdaClientResolvedConfig> {
     readonly input: RemovePermissionCommandInput;
     constructor(input: RemovePermissionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RemovePermissionCommandInput, RemovePermissionCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/TagResourceCommand.d.ts

@@ -6,29 +6,11 @@ export interface TagResourceCommandInput extends TagResourceRequest {
 }
 export interface TagResourceCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Adds <a href="https://docs.aws.amazon.com/lambda/latest/dg/tagging.html">tags</a> to a function.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LambdaClient, TagResourceCommand } from "@aws-sdk/client-lambda"; // ES Modules import
- * // const { LambdaClient, TagResourceCommand } = require("@aws-sdk/client-lambda"); // CommonJS import
- * const client = new LambdaClient(config);
- * const command = new TagResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link TagResourceCommandInput} for command's `input` shape.
- * @see {@link TagResourceCommandOutput} for command's `response` shape.
- * @see {@link LambdaClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class TagResourceCommand extends $Command<TagResourceCommandInput, TagResourceCommandOutput, LambdaClientResolvedConfig> {
     readonly input: TagResourceCommandInput;
     constructor(input: TagResourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TagResourceCommandInput, TagResourceCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/UntagResourceCommand.d.ts

@@ -6,29 +6,11 @@ export interface UntagResourceCommandInput extends UntagResourceRequest {
 }
 export interface UntagResourceCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Removes <a href="https://docs.aws.amazon.com/lambda/latest/dg/tagging.html">tags</a> from a function.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LambdaClient, UntagResourceCommand } from "@aws-sdk/client-lambda"; // ES Modules import
- * // const { LambdaClient, UntagResourceCommand } = require("@aws-sdk/client-lambda"); // CommonJS import
- * const client = new LambdaClient(config);
- * const command = new UntagResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UntagResourceCommandInput} for command's `input` shape.
- * @see {@link UntagResourceCommandOutput} for command's `response` shape.
- * @see {@link LambdaClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UntagResourceCommand extends $Command<UntagResourceCommandInput, UntagResourceCommandOutput, LambdaClientResolvedConfig> {
     readonly input: UntagResourceCommandInput;
     constructor(input: UntagResourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UntagResourceCommandInput, UntagResourceCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/UpdateAliasCommand.d.ts

@@ -6,29 +6,11 @@ export interface UpdateAliasCommandInput extends UpdateAliasRequest {
 }
 export interface UpdateAliasCommandOutput extends AliasConfiguration, __MetadataBearer {
 }
-/**
- * <p>Updates the configuration of a Lambda function <a href="https://docs.aws.amazon.com/lambda/latest/dg/versioning-aliases.html">alias</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LambdaClient, UpdateAliasCommand } from "@aws-sdk/client-lambda"; // ES Modules import
- * // const { LambdaClient, UpdateAliasCommand } = require("@aws-sdk/client-lambda"); // CommonJS import
- * const client = new LambdaClient(config);
- * const command = new UpdateAliasCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateAliasCommandInput} for command's `input` shape.
- * @see {@link UpdateAliasCommandOutput} for command's `response` shape.
- * @see {@link LambdaClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateAliasCommand extends $Command<UpdateAliasCommandInput, UpdateAliasCommandOutput, LambdaClientResolvedConfig> {
     readonly input: UpdateAliasCommandInput;
     constructor(input: UpdateAliasCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateAliasCommandInput, UpdateAliasCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/UpdateCodeSigningConfigCommand.d.ts

@@ -6,30 +6,11 @@ export interface UpdateCodeSigningConfigCommandInput extends UpdateCodeSigningCo
 }
 export interface UpdateCodeSigningConfigCommandOutput extends UpdateCodeSigningConfigResponse, __MetadataBearer {
 }
-/**
- * <p>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. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LambdaClient, UpdateCodeSigningConfigCommand } from "@aws-sdk/client-lambda"; // ES Modules import
- * // const { LambdaClient, UpdateCodeSigningConfigCommand } = require("@aws-sdk/client-lambda"); // CommonJS import
- * const client = new LambdaClient(config);
- * const command = new UpdateCodeSigningConfigCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateCodeSigningConfigCommandInput} for command's `input` shape.
- * @see {@link UpdateCodeSigningConfigCommandOutput} for command's `response` shape.
- * @see {@link LambdaClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateCodeSigningConfigCommand extends $Command<UpdateCodeSigningConfigCommandInput, UpdateCodeSigningConfigCommandOutput, LambdaClientResolvedConfig> {
     readonly input: UpdateCodeSigningConfigCommandInput;
     constructor(input: UpdateCodeSigningConfigCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateCodeSigningConfigCommandInput, UpdateCodeSigningConfigCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/UpdateEventSourceMappingCommand.d.ts

@@ -6,54 +6,11 @@ export interface UpdateEventSourceMappingCommandInput extends UpdateEventSourceM
 }
 export interface UpdateEventSourceMappingCommandOutput extends EventSourceMappingConfiguration, __MetadataBearer {
 }
-/**
- * <p>Updates an event source mapping. You can change the function that Lambda invokes, or pause
- *       invocation and resume later from the same location.</p>
- *
- *          <p>The following error handling options are only available for stream sources (DynamoDB and Kinesis):</p>
- *          <ul>
- *             <li>
- *                <p>
- *                   <code>BisectBatchOnFunctionError</code> - If the function returns an error, split the batch in two and retry.</p>
- *             </li>
- *             <li>
- *                <p>
- *                   <code>DestinationConfig</code> - Send discarded records to an Amazon SQS queue or Amazon SNS topic.</p>
- *             </li>
- *             <li>
- *                <p>
- *                   <code>MaximumRecordAgeInSeconds</code> - 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</p>
- *             </li>
- *             <li>
- *                <p>
- *                   <code>MaximumRetryAttempts</code> - 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.</p>
- *             </li>
- *             <li>
- *                <p>
- *                   <code>ParallelizationFactor</code> - Process multiple batches from each shard concurrently.</p>
- *             </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LambdaClient, UpdateEventSourceMappingCommand } from "@aws-sdk/client-lambda"; // ES Modules import
- * // const { LambdaClient, UpdateEventSourceMappingCommand } = require("@aws-sdk/client-lambda"); // CommonJS import
- * const client = new LambdaClient(config);
- * const command = new UpdateEventSourceMappingCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateEventSourceMappingCommandInput} for command's `input` shape.
- * @see {@link UpdateEventSourceMappingCommandOutput} for command's `response` shape.
- * @see {@link LambdaClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateEventSourceMappingCommand extends $Command<UpdateEventSourceMappingCommandInput, UpdateEventSourceMappingCommandOutput, LambdaClientResolvedConfig> {
     readonly input: UpdateEventSourceMappingCommandInput;
     constructor(input: UpdateEventSourceMappingCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateEventSourceMappingCommandInput, UpdateEventSourceMappingCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/UpdateFunctionCodeCommand.d.ts

@@ -6,37 +6,11 @@ export interface UpdateFunctionCodeCommandInput extends UpdateFunctionCodeReques
 }
 export interface UpdateFunctionCodeCommandOutput extends FunctionConfiguration, __MetadataBearer {
 }
-/**
- * <p>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 <a href="https://docs.aws.amazon.com/lambda/latest/dg/configuration-trustedcode.html">Configuring code signing</a>.</p>
- *
- *          <p>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.</p>
- *          <note>
- *             <p>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.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LambdaClient, UpdateFunctionCodeCommand } from "@aws-sdk/client-lambda"; // ES Modules import
- * // const { LambdaClient, UpdateFunctionCodeCommand } = require("@aws-sdk/client-lambda"); // CommonJS import
- * const client = new LambdaClient(config);
- * const command = new UpdateFunctionCodeCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateFunctionCodeCommandInput} for command's `input` shape.
- * @see {@link UpdateFunctionCodeCommandOutput} for command's `response` shape.
- * @see {@link LambdaClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateFunctionCodeCommand extends $Command<UpdateFunctionCodeCommandInput, UpdateFunctionCodeCommandOutput, LambdaClientResolvedConfig> {
     readonly input: UpdateFunctionCodeCommandInput;
     constructor(input: UpdateFunctionCodeCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateFunctionCodeCommandInput, UpdateFunctionCodeCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/UpdateFunctionConfigurationCommand.d.ts

@@ -6,43 +6,11 @@ export interface UpdateFunctionConfigurationCommandInput extends UpdateFunctionC
 }
 export interface UpdateFunctionConfigurationCommandOutput extends FunctionConfiguration, __MetadataBearer {
 }
-/**
- * <p>Modify the version-specific settings of a Lambda function.</p>
- *
- *          <p>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 <code>LastUpdateStatus</code>, <code>LastUpdateStatusReason</code>, and
- *         <code>LastUpdateStatusReasonCode</code> fields in the response from <a>GetFunctionConfiguration</a>
- *       indicate when the update is complete and the function is processing events with the new configuration. For more
- *       information, see <a href="https://docs.aws.amazon.com/lambda/latest/dg/functions-states.html">Function
- *       States</a>.</p>
- *
- *          <p>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.</p>
- *
- *          <p>To configure function concurrency, use <a>PutFunctionConcurrency</a>. To grant invoke permissions
- *       to an account or Amazon Web Services service, use <a>AddPermission</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LambdaClient, UpdateFunctionConfigurationCommand } from "@aws-sdk/client-lambda"; // ES Modules import
- * // const { LambdaClient, UpdateFunctionConfigurationCommand } = require("@aws-sdk/client-lambda"); // CommonJS import
- * const client = new LambdaClient(config);
- * const command = new UpdateFunctionConfigurationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateFunctionConfigurationCommandInput} for command's `input` shape.
- * @see {@link UpdateFunctionConfigurationCommandOutput} for command's `response` shape.
- * @see {@link LambdaClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateFunctionConfigurationCommand extends $Command<UpdateFunctionConfigurationCommandInput, UpdateFunctionConfigurationCommandOutput, LambdaClientResolvedConfig> {
     readonly input: UpdateFunctionConfigurationCommandInput;
     constructor(input: UpdateFunctionConfigurationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateFunctionConfigurationCommandInput, UpdateFunctionConfigurationCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/UpdateFunctionEventInvokeConfigCommand.d.ts

@@ -6,30 +6,11 @@ export interface UpdateFunctionEventInvokeConfigCommandInput extends UpdateFunct
 }
 export interface UpdateFunctionEventInvokeConfigCommandOutput extends FunctionEventInvokeConfig, __MetadataBearer {
 }
-/**
- * <p>Updates the configuration for asynchronous invocation for a function, version, or alias.</p>
- *          <p>To configure options for asynchronous invocation, use <a>PutFunctionEventInvokeConfig</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LambdaClient, UpdateFunctionEventInvokeConfigCommand } from "@aws-sdk/client-lambda"; // ES Modules import
- * // const { LambdaClient, UpdateFunctionEventInvokeConfigCommand } = require("@aws-sdk/client-lambda"); // CommonJS import
- * const client = new LambdaClient(config);
- * const command = new UpdateFunctionEventInvokeConfigCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateFunctionEventInvokeConfigCommandInput} for command's `input` shape.
- * @see {@link UpdateFunctionEventInvokeConfigCommandOutput} for command's `response` shape.
- * @see {@link LambdaClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateFunctionEventInvokeConfigCommand extends $Command<UpdateFunctionEventInvokeConfigCommandInput, UpdateFunctionEventInvokeConfigCommandOutput, LambdaClientResolvedConfig> {
     readonly input: UpdateFunctionEventInvokeConfigCommandInput;
     constructor(input: UpdateFunctionEventInvokeConfigCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateFunctionEventInvokeConfigCommandInput, UpdateFunctionEventInvokeConfigCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/index.d.ts

@@ -0,0 +1,58 @@
+export * from "./AddLayerVersionPermissionCommand";
+export * from "./AddPermissionCommand";
+export * from "./CreateAliasCommand";
+export * from "./CreateCodeSigningConfigCommand";
+export * from "./CreateEventSourceMappingCommand";
+export * from "./CreateFunctionCommand";
+export * from "./DeleteAliasCommand";
+export * from "./DeleteCodeSigningConfigCommand";
+export * from "./DeleteEventSourceMappingCommand";
+export * from "./DeleteFunctionCodeSigningConfigCommand";
+export * from "./DeleteFunctionCommand";
+export * from "./DeleteFunctionConcurrencyCommand";
+export * from "./DeleteFunctionEventInvokeConfigCommand";
+export * from "./DeleteLayerVersionCommand";
+export * from "./DeleteProvisionedConcurrencyConfigCommand";
+export * from "./GetAccountSettingsCommand";
+export * from "./GetAliasCommand";
+export * from "./GetCodeSigningConfigCommand";
+export * from "./GetEventSourceMappingCommand";
+export * from "./GetFunctionCodeSigningConfigCommand";
+export * from "./GetFunctionCommand";
+export * from "./GetFunctionConcurrencyCommand";
+export * from "./GetFunctionConfigurationCommand";
+export * from "./GetFunctionEventInvokeConfigCommand";
+export * from "./GetLayerVersionByArnCommand";
+export * from "./GetLayerVersionCommand";
+export * from "./GetLayerVersionPolicyCommand";
+export * from "./GetPolicyCommand";
+export * from "./GetProvisionedConcurrencyConfigCommand";
+export * from "./InvokeAsyncCommand";
+export * from "./InvokeCommand";
+export * from "./ListAliasesCommand";
+export * from "./ListCodeSigningConfigsCommand";
+export * from "./ListEventSourceMappingsCommand";
+export * from "./ListFunctionEventInvokeConfigsCommand";
+export * from "./ListFunctionsByCodeSigningConfigCommand";
+export * from "./ListFunctionsCommand";
+export * from "./ListLayerVersionsCommand";
+export * from "./ListLayersCommand";
+export * from "./ListProvisionedConcurrencyConfigsCommand";
+export * from "./ListTagsCommand";
+export * from "./ListVersionsByFunctionCommand";
+export * from "./PublishLayerVersionCommand";
+export * from "./PublishVersionCommand";
+export * from "./PutFunctionCodeSigningConfigCommand";
+export * from "./PutFunctionConcurrencyCommand";
+export * from "./PutFunctionEventInvokeConfigCommand";
+export * from "./PutProvisionedConcurrencyConfigCommand";
+export * from "./RemoveLayerVersionPermissionCommand";
+export * from "./RemovePermissionCommand";
+export * from "./TagResourceCommand";
+export * from "./UntagResourceCommand";
+export * from "./UpdateAliasCommand";
+export * from "./UpdateCodeSigningConfigCommand";
+export * from "./UpdateEventSourceMappingCommand";
+export * from "./UpdateFunctionCodeCommand";
+export * from "./UpdateFunctionConfigurationCommand";
+export * from "./UpdateFunctionEventInvokeConfigCommand";

package/dist-types/ts3.4/index.d.ts

@@ -1,75 +1,6 @@
-export * from "./LambdaClient";
 export * from "./Lambda";
-export * from "./commands/AddLayerVersionPermissionCommand";
-export * from "./commands/AddPermissionCommand";
-export * from "./commands/CreateAliasCommand";
-export * from "./commands/CreateCodeSigningConfigCommand";
-export * from "./commands/CreateEventSourceMappingCommand";
-export * from "./commands/CreateFunctionCommand";
-export * from "./commands/DeleteAliasCommand";
-export * from "./commands/DeleteCodeSigningConfigCommand";
-export * from "./commands/DeleteEventSourceMappingCommand";
-export * from "./commands/DeleteFunctionCommand";
-export * from "./commands/DeleteFunctionCodeSigningConfigCommand";
-export * from "./commands/DeleteFunctionConcurrencyCommand";
-export * from "./commands/DeleteFunctionEventInvokeConfigCommand";
-export * from "./commands/DeleteLayerVersionCommand";
-export * from "./commands/DeleteProvisionedConcurrencyConfigCommand";
-export * from "./commands/GetAccountSettingsCommand";
-export * from "./commands/GetAliasCommand";
-export * from "./commands/GetCodeSigningConfigCommand";
-export * from "./commands/GetEventSourceMappingCommand";
-export * from "./commands/GetFunctionCommand";
-export * from "./waiters/waitForFunctionExists";
-export * from "./commands/GetFunctionCodeSigningConfigCommand";
-export * from "./commands/GetFunctionConcurrencyCommand";
-export * from "./commands/GetFunctionConfigurationCommand";
-export * from "./waiters/waitForFunctionActive";
-export * from "./waiters/waitForFunctionUpdated";
-export * from "./commands/GetFunctionEventInvokeConfigCommand";
-export * from "./commands/GetLayerVersionCommand";
-export * from "./commands/GetLayerVersionByArnCommand";
-export * from "./commands/GetLayerVersionPolicyCommand";
-export * from "./commands/GetPolicyCommand";
-export * from "./commands/GetProvisionedConcurrencyConfigCommand";
-export * from "./commands/InvokeCommand";
-export * from "./commands/InvokeAsyncCommand";
-export * from "./commands/ListAliasesCommand";
-export * from "./pagination/ListAliasesPaginator";
-export * from "./commands/ListCodeSigningConfigsCommand";
-export * from "./pagination/ListCodeSigningConfigsPaginator";
-export * from "./commands/ListEventSourceMappingsCommand";
-export * from "./pagination/ListEventSourceMappingsPaginator";
-export * from "./commands/ListFunctionEventInvokeConfigsCommand";
-export * from "./pagination/ListFunctionEventInvokeConfigsPaginator";
-export * from "./commands/ListFunctionsCommand";
-export * from "./pagination/ListFunctionsPaginator";
-export * from "./commands/ListFunctionsByCodeSigningConfigCommand";
-export * from "./pagination/ListFunctionsByCodeSigningConfigPaginator";
-export * from "./commands/ListLayersCommand";
-export * from "./pagination/ListLayersPaginator";
-export * from "./commands/ListLayerVersionsCommand";
-export * from "./pagination/ListLayerVersionsPaginator";
-export * from "./commands/ListProvisionedConcurrencyConfigsCommand";
-export * from "./pagination/ListProvisionedConcurrencyConfigsPaginator";
-export * from "./commands/ListTagsCommand";
-export * from "./commands/ListVersionsByFunctionCommand";
-export * from "./pagination/ListVersionsByFunctionPaginator";
-export * from "./commands/PublishLayerVersionCommand";
-export * from "./commands/PublishVersionCommand";
-export * from "./commands/PutFunctionCodeSigningConfigCommand";
-export * from "./commands/PutFunctionConcurrencyCommand";
-export * from "./commands/PutFunctionEventInvokeConfigCommand";
-export * from "./commands/PutProvisionedConcurrencyConfigCommand";
-export * from "./commands/RemoveLayerVersionPermissionCommand";
-export * from "./commands/RemovePermissionCommand";
-export * from "./commands/TagResourceCommand";
-export * from "./commands/UntagResourceCommand";
-export * from "./commands/UpdateAliasCommand";
-export * from "./commands/UpdateCodeSigningConfigCommand";
-export * from "./commands/UpdateEventSourceMappingCommand";
-export * from "./commands/UpdateFunctionCodeCommand";
-export * from "./commands/UpdateFunctionConfigurationCommand";
-export * from "./commands/UpdateFunctionEventInvokeConfigCommand";
-export * from "./pagination/Interfaces";
-export * from "./models/index";
+export * from "./LambdaClient";
+export * from "./commands";
+export * from "./models";
+export * from "./pagination";
+export * from "./waiters";