@aws-sdk/client-lambda 3.36.0 → 3.39.0

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

@@ -6,34 +6,11 @@ export interface DeleteFunctionCommandInput extends DeleteFunctionRequest {
 }
 export interface DeleteFunctionCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Deletes a Lambda function. To delete a specific function version, use the <code>Qualifier</code> parameter.
- *       Otherwise, all versions and aliases are deleted.</p>
- *
- *          <p>To delete Lambda event source mappings that invoke a function, use <a>DeleteEventSourceMapping</a>.
- *       For Amazon Web Services services and resources that invoke your function directly, delete the trigger in the service where you
- *       originally configured it.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LambdaClient, DeleteFunctionCommand } from "@aws-sdk/client-lambda"; // ES Modules import
- * // const { LambdaClient, DeleteFunctionCommand } = require("@aws-sdk/client-lambda"); // CommonJS import
- * const client = new LambdaClient(config);
- * const command = new DeleteFunctionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteFunctionCommandInput} for command's `input` shape.
- * @see {@link DeleteFunctionCommandOutput} for command's `response` shape.
- * @see {@link LambdaClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteFunctionCommand extends $Command<DeleteFunctionCommandInput, DeleteFunctionCommandOutput, LambdaClientResolvedConfig> {
     readonly input: DeleteFunctionCommandInput;
     constructor(input: DeleteFunctionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteFunctionCommandInput, DeleteFunctionCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

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

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

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

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

@@ -6,29 +6,11 @@ export interface GetAccountSettingsCommandInput extends GetAccountSettingsReques
 }
 export interface GetAccountSettingsCommandOutput extends GetAccountSettingsResponse, __MetadataBearer {
 }
-/**
- * <p>Retrieves details about your account's <a href="https://docs.aws.amazon.com/lambda/latest/dg/limits.html">limits</a> and usage in an Amazon Web Services Region.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LambdaClient, GetAccountSettingsCommand } from "@aws-sdk/client-lambda"; // ES Modules import
- * // const { LambdaClient, GetAccountSettingsCommand } = require("@aws-sdk/client-lambda"); // CommonJS import
- * const client = new LambdaClient(config);
- * const command = new GetAccountSettingsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetAccountSettingsCommandInput} for command's `input` shape.
- * @see {@link GetAccountSettingsCommandOutput} for command's `response` shape.
- * @see {@link LambdaClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetAccountSettingsCommand extends $Command<GetAccountSettingsCommandInput, GetAccountSettingsCommandOutput, LambdaClientResolvedConfig> {
     readonly input: GetAccountSettingsCommandInput;
     constructor(input: GetAccountSettingsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetAccountSettingsCommandInput, GetAccountSettingsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface GetAliasCommandInput extends GetAliasRequest {
 }
 export interface GetAliasCommandOutput extends AliasConfiguration, __MetadataBearer {
 }
-/**
- * <p>Returns details about 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, GetAliasCommand } from "@aws-sdk/client-lambda"; // ES Modules import
- * // const { LambdaClient, GetAliasCommand } = require("@aws-sdk/client-lambda"); // CommonJS import
- * const client = new LambdaClient(config);
- * const command = new GetAliasCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetAliasCommandInput} for command's `input` shape.
- * @see {@link GetAliasCommandOutput} for command's `response` shape.
- * @see {@link LambdaClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetAliasCommand extends $Command<GetAliasCommandInput, GetAliasCommandOutput, LambdaClientResolvedConfig> {
     readonly input: GetAliasCommandInput;
     constructor(input: GetAliasCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetAliasCommandInput, GetAliasCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface GetCodeSigningConfigCommandInput extends GetCodeSigningConfigRe
 }
 export interface GetCodeSigningConfigCommandOutput extends GetCodeSigningConfigResponse, __MetadataBearer {
 }
-/**
- * <p>Returns information about the specified code signing configuration.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LambdaClient, GetCodeSigningConfigCommand } from "@aws-sdk/client-lambda"; // ES Modules import
- * // const { LambdaClient, GetCodeSigningConfigCommand } = require("@aws-sdk/client-lambda"); // CommonJS import
- * const client = new LambdaClient(config);
- * const command = new GetCodeSigningConfigCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetCodeSigningConfigCommandInput} for command's `input` shape.
- * @see {@link GetCodeSigningConfigCommandOutput} for command's `response` shape.
- * @see {@link LambdaClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetCodeSigningConfigCommand extends $Command<GetCodeSigningConfigCommandInput, GetCodeSigningConfigCommandOutput, LambdaClientResolvedConfig> {
     readonly input: GetCodeSigningConfigCommandInput;
     constructor(input: GetCodeSigningConfigCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetCodeSigningConfigCommandInput, GetCodeSigningConfigCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface GetEventSourceMappingCommandInput extends GetEventSourceMapping
 }
 export interface GetEventSourceMappingCommandOutput extends EventSourceMappingConfiguration, __MetadataBearer {
 }
-/**
- * <p>Returns details about an event source mapping. You can get the identifier of a mapping from the output of
- *         <a>ListEventSourceMappings</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LambdaClient, GetEventSourceMappingCommand } from "@aws-sdk/client-lambda"; // ES Modules import
- * // const { LambdaClient, GetEventSourceMappingCommand } = require("@aws-sdk/client-lambda"); // CommonJS import
- * const client = new LambdaClient(config);
- * const command = new GetEventSourceMappingCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetEventSourceMappingCommandInput} for command's `input` shape.
- * @see {@link GetEventSourceMappingCommandOutput} for command's `response` shape.
- * @see {@link LambdaClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetEventSourceMappingCommand extends $Command<GetEventSourceMappingCommandInput, GetEventSourceMappingCommandOutput, LambdaClientResolvedConfig> {
     readonly input: GetEventSourceMappingCommandInput;
     constructor(input: GetEventSourceMappingCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetEventSourceMappingCommandInput, GetEventSourceMappingCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

@@ -6,30 +6,11 @@ export interface GetFunctionConcurrencyCommandInput extends GetFunctionConcurren
 }
 export interface GetFunctionConcurrencyCommandOutput extends GetFunctionConcurrencyResponse, __MetadataBearer {
 }
-/**
- * <p>Returns details about the reserved concurrency configuration for a function. To set a concurrency limit for a
- *       function, use <a>PutFunctionConcurrency</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LambdaClient, GetFunctionConcurrencyCommand } from "@aws-sdk/client-lambda"; // ES Modules import
- * // const { LambdaClient, GetFunctionConcurrencyCommand } = require("@aws-sdk/client-lambda"); // CommonJS import
- * const client = new LambdaClient(config);
- * const command = new GetFunctionConcurrencyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetFunctionConcurrencyCommandInput} for command's `input` shape.
- * @see {@link GetFunctionConcurrencyCommandOutput} for command's `response` shape.
- * @see {@link LambdaClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetFunctionConcurrencyCommand extends $Command<GetFunctionConcurrencyCommandInput, GetFunctionConcurrencyCommandOutput, LambdaClientResolvedConfig> {
     readonly input: GetFunctionConcurrencyCommandInput;
     constructor(input: GetFunctionConcurrencyCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetFunctionConcurrencyCommandInput, GetFunctionConcurrencyCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface GetFunctionConfigurationCommandInput extends GetFunctionConfigu
 }
 export interface GetFunctionConfigurationCommandOutput extends FunctionConfiguration, __MetadataBearer {
 }
-/**
- * <p>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 <a>UpdateFunctionConfiguration</a>.</p>
- *          <p>To get all of a function's details, including function-level settings, use <a>GetFunction</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LambdaClient, GetFunctionConfigurationCommand } from "@aws-sdk/client-lambda"; // ES Modules import
- * // const { LambdaClient, GetFunctionConfigurationCommand } = require("@aws-sdk/client-lambda"); // CommonJS import
- * const client = new LambdaClient(config);
- * const command = new GetFunctionConfigurationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetFunctionConfigurationCommandInput} for command's `input` shape.
- * @see {@link GetFunctionConfigurationCommandOutput} for command's `response` shape.
- * @see {@link LambdaClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetFunctionConfigurationCommand extends $Command<GetFunctionConfigurationCommandInput, GetFunctionConfigurationCommandOutput, LambdaClientResolvedConfig> {
     readonly input: GetFunctionConfigurationCommandInput;
     constructor(input: GetFunctionConfigurationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetFunctionConfigurationCommandInput, GetFunctionConfigurationCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

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

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

@@ -6,30 +6,11 @@ export interface GetLayerVersionPolicyCommandInput extends GetLayerVersionPolicy
 }
 export interface GetLayerVersionPolicyCommandOutput extends GetLayerVersionPolicyResponse, __MetadataBearer {
 }
-/**
- * <p>Returns the permission 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, GetLayerVersionPolicyCommand } from "@aws-sdk/client-lambda"; // ES Modules import
- * // const { LambdaClient, GetLayerVersionPolicyCommand } = require("@aws-sdk/client-lambda"); // CommonJS import
- * const client = new LambdaClient(config);
- * const command = new GetLayerVersionPolicyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetLayerVersionPolicyCommandInput} for command's `input` shape.
- * @see {@link GetLayerVersionPolicyCommandOutput} for command's `response` shape.
- * @see {@link LambdaClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetLayerVersionPolicyCommand extends $Command<GetLayerVersionPolicyCommandInput, GetLayerVersionPolicyCommandOutput, LambdaClientResolvedConfig> {
     readonly input: GetLayerVersionPolicyCommandInput;
     constructor(input: GetLayerVersionPolicyCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetLayerVersionPolicyCommandInput, GetLayerVersionPolicyCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,29 +6,11 @@ export interface GetProvisionedConcurrencyConfigCommandInput extends GetProvisio
 }
 export interface GetProvisionedConcurrencyConfigCommandOutput extends GetProvisionedConcurrencyConfigResponse, __MetadataBearer {
 }
-/**
- * <p>Retrieves the provisioned concurrency configuration for 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, GetProvisionedConcurrencyConfigCommand } from "@aws-sdk/client-lambda"; // ES Modules import
- * // const { LambdaClient, GetProvisionedConcurrencyConfigCommand } = require("@aws-sdk/client-lambda"); // CommonJS import
- * const client = new LambdaClient(config);
- * const command = new GetProvisionedConcurrencyConfigCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetProvisionedConcurrencyConfigCommandInput} for command's `input` shape.
- * @see {@link GetProvisionedConcurrencyConfigCommandOutput} for command's `response` shape.
- * @see {@link LambdaClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetProvisionedConcurrencyConfigCommand extends $Command<GetProvisionedConcurrencyConfigCommandInput, GetProvisionedConcurrencyConfigCommandOutput, LambdaClientResolvedConfig> {
     readonly input: GetProvisionedConcurrencyConfigCommandInput;
     constructor(input: GetProvisionedConcurrencyConfigCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetProvisionedConcurrencyConfigCommandInput, GetProvisionedConcurrencyConfigCommandOutput>;
     private serialize;
     private deserialize;