@aws-sdk/client-lambda 3.36.0 → 3.39.0

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

@@ -1,49 +1,22 @@
-/// <reference types="node" />
+
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
 import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
 import { InvokeAsyncRequest, InvokeAsyncResponse } from "../models/models_0";
 declare type InvokeAsyncCommandInputType = Pick<InvokeAsyncRequest, Exclude<keyof InvokeAsyncRequest, "InvokeArgs">> & {
-    /**
-     * For *`InvokeAsyncRequest["InvokeArgs"]`*, see {@link InvokeAsyncRequest.InvokeArgs}.
-     */
+    
     InvokeArgs: InvokeAsyncRequest["InvokeArgs"] | string | Uint8Array | Buffer;
 };
-/**
- * This interface extends from `InvokeAsyncRequest` interface. There are more parameters than `InvokeArgs` defined in {@link InvokeAsyncRequest}
- */
+
 export interface InvokeAsyncCommandInput extends InvokeAsyncCommandInputType {
 }
 export interface InvokeAsyncCommandOutput extends InvokeAsyncResponse, __MetadataBearer {
 }
-/**
- * @deprecated
- *
- * <important>
- *             <p>For asynchronous function invocation, use <a>Invoke</a>.</p>
- *          </important>
- *          <p>Invokes a function asynchronously.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LambdaClient, InvokeAsyncCommand } from "@aws-sdk/client-lambda"; // ES Modules import
- * // const { LambdaClient, InvokeAsyncCommand } = require("@aws-sdk/client-lambda"); // CommonJS import
- * const client = new LambdaClient(config);
- * const command = new InvokeAsyncCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link InvokeAsyncCommandInput} for command's `input` shape.
- * @see {@link InvokeAsyncCommandOutput} for command's `response` shape.
- * @see {@link LambdaClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class InvokeAsyncCommand extends $Command<InvokeAsyncCommandInput, InvokeAsyncCommandOutput, LambdaClientResolvedConfig> {
     readonly input: InvokeAsyncCommandInput;
     constructor(input: InvokeAsyncCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<InvokeAsyncCommandInput, InvokeAsyncCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,55 +6,11 @@ export interface InvokeCommandInput extends InvocationRequest {
 }
 export interface InvokeCommandOutput extends InvocationResponse, __MetadataBearer {
 }
-/**
- * <p>Invokes a Lambda function. You can invoke a function synchronously (and wait for the response), or
- *       asynchronously. To invoke a function asynchronously, set <code>InvocationType</code> to <code>Event</code>.</p>
- *
- *          <p>For <a href="https://docs.aws.amazon.com/lambda/latest/dg/invocation-sync.html">synchronous invocation</a>,
- *       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 <a href="https://docs.aws.amazon.com/lambda/latest/dg/monitoring-functions.html">execution log</a> and <a href="https://docs.aws.amazon.com/lambda/latest/dg/lambda-x-ray.html">trace</a>.</p>
- *
- *          <p>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 <a href="https://docs.aws.amazon.com/lambda/latest/dg/retries-on-errors.html">Retry Behavior</a>.</p>
- *
- *          <p>For <a href="https://docs.aws.amazon.com/lambda/latest/dg/invocation-async.html">asynchronous invocation</a>,
- *       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 <a href="https://docs.aws.amazon.com/lambda/latest/dg/invocation-async.html#dlq">dead-letter queue</a>.</p>
- *
- *          <p>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, <a href="https://docs.aws.amazon.com/lambda/latest/dg/limits.html">limit errors</a>, or issues with your function's code and configuration.
- *       For example, Lambda returns <code>TooManyRequestsException</code> if executing the function would cause you to
- *       exceed a concurrency limit at either the account level (<code>ConcurrentInvocationLimitExceeded</code>) or
- *       function level (<code>ReservedFunctionConcurrentInvocationLimitExceeded</code>).</p>
- *
- *          <p>For functions with a long timeout, your client might be disconnected 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.</p>
- *
- *          <p>This operation requires permission for the <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/list_awslambda.html">lambda:InvokeFunction</a> action.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LambdaClient, InvokeCommand } from "@aws-sdk/client-lambda"; // ES Modules import
- * // const { LambdaClient, InvokeCommand } = require("@aws-sdk/client-lambda"); // CommonJS import
- * const client = new LambdaClient(config);
- * const command = new InvokeCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link InvokeCommandInput} for command's `input` shape.
- * @see {@link InvokeCommandOutput} for command's `response` shape.
- * @see {@link LambdaClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class InvokeCommand extends $Command<InvokeCommandInput, InvokeCommandOutput, LambdaClientResolvedConfig> {
     readonly input: InvokeCommandInput;
     constructor(input: InvokeCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<InvokeCommandInput, InvokeCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,31 +6,11 @@ export interface ListCodeSigningConfigsCommandInput extends ListCodeSigningConfi
 }
 export interface ListCodeSigningConfigsCommandOutput extends ListCodeSigningConfigsResponse, __MetadataBearer {
 }
-/**
- * <p>Returns a list of <a href="https://docs.aws.amazon.com/lambda/latest/dg/configuring-codesigning.html">code
- *         signing configurations</a>. A request returns up to 10,000 configurations per
- *       call. You can use the <code>MaxItems</code> parameter to return fewer configurations per call. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LambdaClient, ListCodeSigningConfigsCommand } from "@aws-sdk/client-lambda"; // ES Modules import
- * // const { LambdaClient, ListCodeSigningConfigsCommand } = require("@aws-sdk/client-lambda"); // CommonJS import
- * const client = new LambdaClient(config);
- * const command = new ListCodeSigningConfigsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListCodeSigningConfigsCommandInput} for command's `input` shape.
- * @see {@link ListCodeSigningConfigsCommandOutput} for command's `response` shape.
- * @see {@link LambdaClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListCodeSigningConfigsCommand extends $Command<ListCodeSigningConfigsCommandInput, ListCodeSigningConfigsCommandOutput, LambdaClientResolvedConfig> {
     readonly input: ListCodeSigningConfigsCommandInput;
     constructor(input: ListCodeSigningConfigsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListCodeSigningConfigsCommandInput, ListCodeSigningConfigsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface ListEventSourceMappingsCommandInput extends ListEventSourceMapp
 }
 export interface ListEventSourceMappingsCommandOutput extends ListEventSourceMappingsResponse, __MetadataBearer {
 }
-/**
- * <p>Lists event source mappings. Specify an <code>EventSourceArn</code> to only show event source mappings for a
- *       single event source.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LambdaClient, ListEventSourceMappingsCommand } from "@aws-sdk/client-lambda"; // ES Modules import
- * // const { LambdaClient, ListEventSourceMappingsCommand } = require("@aws-sdk/client-lambda"); // CommonJS import
- * const client = new LambdaClient(config);
- * const command = new ListEventSourceMappingsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListEventSourceMappingsCommandInput} for command's `input` shape.
- * @see {@link ListEventSourceMappingsCommandOutput} for command's `response` shape.
- * @see {@link LambdaClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListEventSourceMappingsCommand extends $Command<ListEventSourceMappingsCommandInput, ListEventSourceMappingsCommandOutput, LambdaClientResolvedConfig> {
     readonly input: ListEventSourceMappingsCommandInput;
     constructor(input: ListEventSourceMappingsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListEventSourceMappingsCommandInput, ListEventSourceMappingsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface ListFunctionEventInvokeConfigsCommandInput extends ListFunction
 }
 export interface ListFunctionEventInvokeConfigsCommandOutput extends ListFunctionEventInvokeConfigsResponse, __MetadataBearer {
 }
-/**
- * <p>Retrieves a list of configurations for asynchronous invocation for a function.</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, ListFunctionEventInvokeConfigsCommand } from "@aws-sdk/client-lambda"; // ES Modules import
- * // const { LambdaClient, ListFunctionEventInvokeConfigsCommand } = require("@aws-sdk/client-lambda"); // CommonJS import
- * const client = new LambdaClient(config);
- * const command = new ListFunctionEventInvokeConfigsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListFunctionEventInvokeConfigsCommandInput} for command's `input` shape.
- * @see {@link ListFunctionEventInvokeConfigsCommandOutput} for command's `response` shape.
- * @see {@link LambdaClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListFunctionEventInvokeConfigsCommand extends $Command<ListFunctionEventInvokeConfigsCommandInput, ListFunctionEventInvokeConfigsCommandOutput, LambdaClientResolvedConfig> {
     readonly input: ListFunctionEventInvokeConfigsCommandInput;
     constructor(input: ListFunctionEventInvokeConfigsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListFunctionEventInvokeConfigsCommandInput, ListFunctionEventInvokeConfigsCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,37 +6,11 @@ export interface ListFunctionsCommandInput extends ListFunctionsRequest {
 }
 export interface ListFunctionsCommandOutput extends ListFunctionsResponse, __MetadataBearer {
 }
-/**
- * <p>Returns a list of Lambda functions, with the version-specific configuration of each. Lambda returns up to 50
- *       functions per call.</p>
- *          <p>Set <code>FunctionVersion</code> to <code>ALL</code> to include all published versions of each function in
- *       addition to the unpublished version. </p>
- *          <note>
- *             <p>The <code>ListFunctions</code> action returns a subset of the <a>FunctionConfiguration</a> fields.
- *       To get the additional fields (State, StateReasonCode, StateReason, LastUpdateStatus, LastUpdateStatusReason, LastUpdateStatusReasonCode)
- *       for a function or version, use <a>GetFunction</a>.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LambdaClient, ListFunctionsCommand } from "@aws-sdk/client-lambda"; // ES Modules import
- * // const { LambdaClient, ListFunctionsCommand } = require("@aws-sdk/client-lambda"); // CommonJS import
- * const client = new LambdaClient(config);
- * const command = new ListFunctionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListFunctionsCommandInput} for command's `input` shape.
- * @see {@link ListFunctionsCommandOutput} for command's `response` shape.
- * @see {@link LambdaClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListFunctionsCommand extends $Command<ListFunctionsCommandInput, ListFunctionsCommandOutput, LambdaClientResolvedConfig> {
     readonly input: ListFunctionsCommandInput;
     constructor(input: ListFunctionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListFunctionsCommandInput, ListFunctionsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface ListLayerVersionsCommandInput extends ListLayerVersionsRequest
 }
 export interface ListLayerVersionsCommandOutput extends ListLayerVersionsResponse, __MetadataBearer {
 }
-/**
- * <p>Lists the versions of an <a href="https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html">Lambda
- *         layer</a>. Versions that have been deleted aren't listed. Specify a <a href="https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html">runtime identifier</a> 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.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LambdaClient, ListLayerVersionsCommand } from "@aws-sdk/client-lambda"; // ES Modules import
- * // const { LambdaClient, ListLayerVersionsCommand } = require("@aws-sdk/client-lambda"); // CommonJS import
- * const client = new LambdaClient(config);
- * const command = new ListLayerVersionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListLayerVersionsCommandInput} for command's `input` shape.
- * @see {@link ListLayerVersionsCommandOutput} for command's `response` shape.
- * @see {@link LambdaClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListLayerVersionsCommand extends $Command<ListLayerVersionsCommandInput, ListLayerVersionsCommandOutput, LambdaClientResolvedConfig> {
     readonly input: ListLayerVersionsCommandInput;
     constructor(input: ListLayerVersionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListLayerVersionsCommandInput, ListLayerVersionsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,34 +6,11 @@ export interface ListLayersCommandInput extends ListLayersRequest {
 }
 export interface ListLayersCommandOutput extends ListLayersResponse, __MetadataBearer {
 }
-/**
- * <p>Lists <a href="https://docs.aws.amazon.com/lambda/latest/dg/invocation-layers.html">Lambda
- *         layers</a> and shows information about the latest version of each. Specify a
- *         <a href="https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html">runtime
- *         identifier</a> 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  <a href="https://docs.aws.amazon.com/lambda/latest/dg/foundation-arch.html">instruction set architecture</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LambdaClient, ListLayersCommand } from "@aws-sdk/client-lambda"; // ES Modules import
- * // const { LambdaClient, ListLayersCommand } = require("@aws-sdk/client-lambda"); // CommonJS import
- * const client = new LambdaClient(config);
- * const command = new ListLayersCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListLayersCommandInput} for command's `input` shape.
- * @see {@link ListLayersCommandOutput} for command's `response` shape.
- * @see {@link LambdaClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListLayersCommand extends $Command<ListLayersCommandInput, ListLayersCommandOutput, LambdaClientResolvedConfig> {
     readonly input: ListLayersCommandInput;
     constructor(input: ListLayersCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListLayersCommandInput, ListLayersCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

@@ -6,30 +6,11 @@ export interface ListVersionsByFunctionCommandInput extends ListVersionsByFuncti
 }
 export interface ListVersionsByFunctionCommandOutput extends ListVersionsByFunctionResponse, __MetadataBearer {
 }
-/**
- * <p>Returns a list of <a href="https://docs.aws.amazon.com/lambda/latest/dg/versioning-aliases.html">versions</a>,
- *       with the version-specific configuration of each. Lambda returns up to 50 versions per call.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LambdaClient, ListVersionsByFunctionCommand } from "@aws-sdk/client-lambda"; // ES Modules import
- * // const { LambdaClient, ListVersionsByFunctionCommand } = require("@aws-sdk/client-lambda"); // CommonJS import
- * const client = new LambdaClient(config);
- * const command = new ListVersionsByFunctionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListVersionsByFunctionCommandInput} for command's `input` shape.
- * @see {@link ListVersionsByFunctionCommandOutput} for command's `response` shape.
- * @see {@link LambdaClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListVersionsByFunctionCommand extends $Command<ListVersionsByFunctionCommandInput, ListVersionsByFunctionCommandOutput, LambdaClientResolvedConfig> {
     readonly input: ListVersionsByFunctionCommandInput;
     constructor(input: ListVersionsByFunctionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListVersionsByFunctionCommandInput, ListVersionsByFunctionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface PublishLayerVersionCommandInput extends PublishLayerVersionRequ
 }
 export interface PublishLayerVersionCommandOutput extends PublishLayerVersionResponse, __MetadataBearer {
 }
-/**
- * <p>Creates an <a href="https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html">Lambda
- *         layer</a> from a ZIP archive. Each time you call <code>PublishLayerVersion</code> with the same
- *       layer name, a new version is created.</p>
- *          <p>Add layers to your function with <a>CreateFunction</a> or <a>UpdateFunctionConfiguration</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LambdaClient, PublishLayerVersionCommand } from "@aws-sdk/client-lambda"; // ES Modules import
- * // const { LambdaClient, PublishLayerVersionCommand } = require("@aws-sdk/client-lambda"); // CommonJS import
- * const client = new LambdaClient(config);
- * const command = new PublishLayerVersionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PublishLayerVersionCommandInput} for command's `input` shape.
- * @see {@link PublishLayerVersionCommandOutput} for command's `response` shape.
- * @see {@link LambdaClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PublishLayerVersionCommand extends $Command<PublishLayerVersionCommandInput, PublishLayerVersionCommandOutput, LambdaClientResolvedConfig> {
     readonly input: PublishLayerVersionCommandInput;
     constructor(input: PublishLayerVersionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PublishLayerVersionCommandInput, PublishLayerVersionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,37 +6,11 @@ export interface PublishVersionCommandInput extends PublishVersionRequest {
 }
 export interface PublishVersionCommandOutput extends FunctionConfiguration, __MetadataBearer {
 }
-/**
- * <p>Creates a <a href="https://docs.aws.amazon.com/lambda/latest/dg/versioning-aliases.html">version</a> 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.</p>
- *
- *          <p>Lambda doesn't publish a version if the function's configuration and code haven't changed since the last
- *       version. Use <a>UpdateFunctionCode</a> or <a>UpdateFunctionConfiguration</a> to update the
- *       function before publishing a version.</p>
- *
- *          <p>Clients can invoke versions directly or with an alias. To create an alias, use <a>CreateAlias</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LambdaClient, PublishVersionCommand } from "@aws-sdk/client-lambda"; // ES Modules import
- * // const { LambdaClient, PublishVersionCommand } = require("@aws-sdk/client-lambda"); // CommonJS import
- * const client = new LambdaClient(config);
- * const command = new PublishVersionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PublishVersionCommandInput} for command's `input` shape.
- * @see {@link PublishVersionCommandOutput} for command's `response` shape.
- * @see {@link LambdaClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PublishVersionCommand extends $Command<PublishVersionCommandInput, PublishVersionCommandOutput, LambdaClientResolvedConfig> {
     readonly input: PublishVersionCommandInput;
     constructor(input: PublishVersionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PublishVersionCommandInput, PublishVersionCommandOutput>;
     private serialize;
     private deserialize;

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

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