@aws-sdk/client-lambda 3.296.0 → 3.298.0

package/dist-types/commands/AddPermissionCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
 import { AddPermissionRequest, AddPermissionResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link AddPermissionCommand}.
  */
 export interface AddPermissionCommandInput extends AddPermissionRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link AddPermissionCommand}.
  */
 export interface AddPermissionCommandOutput extends AddPermissionResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Grants an Amazon Web Service, Amazon Web Services account, or Amazon Web Services organization
  *       permission to use a function. You can apply the policy at the function level, or specify a qualifier to restrict
  *       access to a single version or alias. If you use a qualifier, the invoker must use the full Amazon Resource Name
@@ -37,6 +42,8 @@ export interface AddPermissionCommandOutput extends AddPermissionResponse, __Met
  * const response = await client.send(command);
  * ```
  *
+ * @param AddPermissionCommandInput - {@link AddPermissionCommandInput}
+ * @returns {@link AddPermissionCommandOutput}
  * @see {@link AddPermissionCommandInput} for command's `input` shape.
  * @see {@link AddPermissionCommandOutput} for command's `response` shape.
  * @see {@link LambdaClientResolvedConfig | config} for LambdaClient's `config` shape.
@@ -68,11 +75,20 @@ export interface AddPermissionCommandOutput extends AddPermissionResponse, __Met
 export declare class AddPermissionCommand extends $Command<AddPermissionCommandInput, AddPermissionCommandOutput, LambdaClientResolvedConfig> {
     readonly input: AddPermissionCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: AddPermissionCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AddPermissionCommandInput, AddPermissionCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/CreateAliasCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
 import { AliasConfiguration, CreateAliasRequest } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link CreateAliasCommand}.
  */
 export interface CreateAliasCommandInput extends CreateAliasRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateAliasCommand}.
  */
 export interface CreateAliasCommandOutput extends AliasConfiguration, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates an <a href="https://docs.aws.amazon.com/lambda/latest/dg/configuration-aliases.html">alias</a> for a
  *       Lambda function version. Use aliases to provide clients with a function identifier that you can update to invoke a
  *       different version.</p>
@@ -30,6 +35,8 @@ export interface CreateAliasCommandOutput extends AliasConfiguration, __Metadata
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateAliasCommandInput - {@link CreateAliasCommandInput}
+ * @returns {@link CreateAliasCommandOutput}
  * @see {@link CreateAliasCommandInput} for command's `input` shape.
  * @see {@link CreateAliasCommandOutput} for command's `response` shape.
  * @see {@link LambdaClientResolvedConfig | config} for LambdaClient's `config` shape.
@@ -54,11 +61,20 @@ export interface CreateAliasCommandOutput extends AliasConfiguration, __Metadata
 export declare class CreateAliasCommand extends $Command<CreateAliasCommandInput, CreateAliasCommandOutput, LambdaClientResolvedConfig> {
     readonly input: CreateAliasCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateAliasCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateAliasCommandInput, CreateAliasCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/CreateCodeSigningConfigCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
 import { CreateCodeSigningConfigRequest, CreateCodeSigningConfigResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link CreateCodeSigningConfigCommand}.
  */
 export interface CreateCodeSigningConfigCommandInput extends CreateCodeSigningConfigRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateCodeSigningConfigCommand}.
  */
 export interface CreateCodeSigningConfigCommandOutput extends CreateCodeSigningConfigResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a code signing configuration. A <a href="https://docs.aws.amazon.com/lambda/latest/dg/configuration-codesigning.html">code signing configuration</a> defines a list of
  *       allowed signing profiles and defines the code-signing validation policy (action to be taken if deployment
  *       validation checks fail). </p>
@@ -27,6 +32,8 @@ export interface CreateCodeSigningConfigCommandOutput extends CreateCodeSigningC
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateCodeSigningConfigCommandInput - {@link CreateCodeSigningConfigCommandInput}
+ * @returns {@link CreateCodeSigningConfigCommandOutput}
  * @see {@link CreateCodeSigningConfigCommandInput} for command's `input` shape.
  * @see {@link CreateCodeSigningConfigCommandOutput} for command's `response` shape.
  * @see {@link LambdaClientResolvedConfig | config} for LambdaClient's `config` shape.
@@ -42,11 +49,20 @@ export interface CreateCodeSigningConfigCommandOutput extends CreateCodeSigningC
 export declare class CreateCodeSigningConfigCommand extends $Command<CreateCodeSigningConfigCommandInput, CreateCodeSigningConfigCommandOutput, LambdaClientResolvedConfig> {
     readonly input: CreateCodeSigningConfigCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateCodeSigningConfigCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateCodeSigningConfigCommandInput, CreateCodeSigningConfigCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/CreateEventSourceMappingCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
 import { CreateEventSourceMappingRequest, EventSourceMappingConfiguration } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link CreateEventSourceMappingCommand}.
  */
 export interface CreateEventSourceMappingCommandInput extends CreateEventSourceMappingRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateEventSourceMappingCommand}.
  */
 export interface CreateEventSourceMappingCommandOutput extends EventSourceMappingConfiguration, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a mapping between an event source and an Lambda function. Lambda reads items from the event source and invokes the function.</p>
  *          <p>For details about how to configure different event sources, see the following topics. </p>
  *          <ul>
@@ -126,6 +131,8 @@ export interface CreateEventSourceMappingCommandOutput extends EventSourceMappin
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateEventSourceMappingCommandInput - {@link CreateEventSourceMappingCommandInput}
+ * @returns {@link CreateEventSourceMappingCommandOutput}
  * @see {@link CreateEventSourceMappingCommandInput} for command's `input` shape.
  * @see {@link CreateEventSourceMappingCommandOutput} for command's `response` shape.
  * @see {@link LambdaClientResolvedConfig | config} for LambdaClient's `config` shape.
@@ -150,11 +157,20 @@ export interface CreateEventSourceMappingCommandOutput extends EventSourceMappin
 export declare class CreateEventSourceMappingCommand extends $Command<CreateEventSourceMappingCommandInput, CreateEventSourceMappingCommandOutput, LambdaClientResolvedConfig> {
     readonly input: CreateEventSourceMappingCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateEventSourceMappingCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateEventSourceMappingCommandInput, CreateEventSourceMappingCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/CreateFunctionCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
 import { CreateFunctionRequest, FunctionConfiguration } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link CreateFunctionCommand}.
  */
 export interface CreateFunctionCommandInput extends CreateFunctionRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateFunctionCommand}.
  */
 export interface CreateFunctionCommandOutput extends FunctionConfiguration, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a Lambda function. To create a function, you need a <a href="https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-package.html">deployment package</a> and an <a href="https://docs.aws.amazon.com/lambda/latest/dg/intro-permission-model.html#lambda-intro-execution-role">execution role</a>. The
  *       deployment package is a .zip file archive or container image that contains your function code. The execution role
  *       grants the function permission to use Amazon Web Services, such as Amazon CloudWatch Logs for log
@@ -62,6 +67,8 @@ export interface CreateFunctionCommandOutput extends FunctionConfiguration, __Me
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateFunctionCommandInput - {@link CreateFunctionCommandInput}
+ * @returns {@link CreateFunctionCommandOutput}
  * @see {@link CreateFunctionCommandInput} for command's `input` shape.
  * @see {@link CreateFunctionCommandOutput} for command's `response` shape.
  * @see {@link LambdaClientResolvedConfig | config} for LambdaClient's `config` shape.
@@ -100,11 +107,20 @@ export interface CreateFunctionCommandOutput extends FunctionConfiguration, __Me
 export declare class CreateFunctionCommand extends $Command<CreateFunctionCommandInput, CreateFunctionCommandOutput, LambdaClientResolvedConfig> {
     readonly input: CreateFunctionCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateFunctionCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateFunctionCommandInput, CreateFunctionCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/CreateFunctionUrlConfigCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
 import { CreateFunctionUrlConfigRequest, CreateFunctionUrlConfigResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link CreateFunctionUrlConfigCommand}.
  */
 export interface CreateFunctionUrlConfigCommandInput extends CreateFunctionUrlConfigRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateFunctionUrlConfigCommand}.
  */
 export interface CreateFunctionUrlConfigCommandOutput extends CreateFunctionUrlConfigResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a Lambda function URL with the specified configuration parameters. A function URL is
  *       a dedicated HTTP(S) endpoint that you can use to invoke your function.</p>
  * @example
@@ -26,6 +31,8 @@ export interface CreateFunctionUrlConfigCommandOutput extends CreateFunctionUrlC
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateFunctionUrlConfigCommandInput - {@link CreateFunctionUrlConfigCommandInput}
+ * @returns {@link CreateFunctionUrlConfigCommandOutput}
  * @see {@link CreateFunctionUrlConfigCommandInput} for command's `input` shape.
  * @see {@link CreateFunctionUrlConfigCommandOutput} for command's `response` shape.
  * @see {@link LambdaClientResolvedConfig | config} for LambdaClient's `config` shape.
@@ -50,11 +57,20 @@ export interface CreateFunctionUrlConfigCommandOutput extends CreateFunctionUrlC
 export declare class CreateFunctionUrlConfigCommand extends $Command<CreateFunctionUrlConfigCommandInput, CreateFunctionUrlConfigCommandOutput, LambdaClientResolvedConfig> {
     readonly input: CreateFunctionUrlConfigCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateFunctionUrlConfigCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateFunctionUrlConfigCommandInput, CreateFunctionUrlConfigCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/DeleteAliasCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
 import { DeleteAliasRequest } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link DeleteAliasCommand}.
  */
 export interface DeleteAliasCommandInput extends DeleteAliasRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteAliasCommand}.
  */
 export interface DeleteAliasCommandOutput extends __MetadataBearer {
 }
 /**
+ * @public
  * <p>Deletes a Lambda function <a href="https://docs.aws.amazon.com/lambda/latest/dg/configuration-aliases.html">alias</a>.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface DeleteAliasCommandOutput extends __MetadataBearer {
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteAliasCommandInput - {@link DeleteAliasCommandInput}
+ * @returns {@link DeleteAliasCommandOutput}
  * @see {@link DeleteAliasCommandInput} for command's `input` shape.
  * @see {@link DeleteAliasCommandOutput} for command's `response` shape.
  * @see {@link LambdaClientResolvedConfig | config} for LambdaClient's `config` shape.
@@ -46,11 +53,20 @@ export interface DeleteAliasCommandOutput extends __MetadataBearer {
 export declare class DeleteAliasCommand extends $Command<DeleteAliasCommandInput, DeleteAliasCommandOutput, LambdaClientResolvedConfig> {
     readonly input: DeleteAliasCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteAliasCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteAliasCommandInput, DeleteAliasCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/DeleteCodeSigningConfigCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
 import { DeleteCodeSigningConfigRequest, DeleteCodeSigningConfigResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link DeleteCodeSigningConfigCommand}.
  */
 export interface DeleteCodeSigningConfigCommandInput extends DeleteCodeSigningConfigRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteCodeSigningConfigCommand}.
  */
 export interface DeleteCodeSigningConfigCommandOutput extends DeleteCodeSigningConfigResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Deletes the code signing configuration. You can delete the code signing configuration only if no function is
  *       using it. </p>
  * @example
@@ -26,6 +31,8 @@ export interface DeleteCodeSigningConfigCommandOutput extends DeleteCodeSigningC
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteCodeSigningConfigCommandInput - {@link DeleteCodeSigningConfigCommandInput}
+ * @returns {@link DeleteCodeSigningConfigCommandOutput}
  * @see {@link DeleteCodeSigningConfigCommandInput} for command's `input` shape.
  * @see {@link DeleteCodeSigningConfigCommandOutput} for command's `response` shape.
  * @see {@link LambdaClientResolvedConfig | config} for LambdaClient's `config` shape.
@@ -47,11 +54,20 @@ export interface DeleteCodeSigningConfigCommandOutput extends DeleteCodeSigningC
 export declare class DeleteCodeSigningConfigCommand extends $Command<DeleteCodeSigningConfigCommandInput, DeleteCodeSigningConfigCommandOutput, LambdaClientResolvedConfig> {
     readonly input: DeleteCodeSigningConfigCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteCodeSigningConfigCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteCodeSigningConfigCommandInput, DeleteCodeSigningConfigCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/DeleteEventSourceMappingCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
 import { DeleteEventSourceMappingRequest, EventSourceMappingConfiguration } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link DeleteEventSourceMappingCommand}.
  */
 export interface DeleteEventSourceMappingCommandInput extends DeleteEventSourceMappingRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteEventSourceMappingCommand}.
  */
 export interface DeleteEventSourceMappingCommandOutput extends EventSourceMappingConfiguration, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Deletes an <a href="https://docs.aws.amazon.com/lambda/latest/dg/intro-invocation-modes.html">event source
  *         mapping</a>. You can get the identifier of a mapping from the output of <a>ListEventSourceMappings</a>.</p>
  *          <p>When you delete an event source mapping, it enters a <code>Deleting</code> state and might not be completely
@@ -28,6 +33,8 @@ export interface DeleteEventSourceMappingCommandOutput extends EventSourceMappin
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteEventSourceMappingCommandInput - {@link DeleteEventSourceMappingCommandInput}
+ * @returns {@link DeleteEventSourceMappingCommandOutput}
  * @see {@link DeleteEventSourceMappingCommandInput} for command's `input` shape.
  * @see {@link DeleteEventSourceMappingCommandOutput} for command's `response` shape.
  * @see {@link LambdaClientResolvedConfig | config} for LambdaClient's `config` shape.
@@ -53,11 +60,20 @@ export interface DeleteEventSourceMappingCommandOutput extends EventSourceMappin
 export declare class DeleteEventSourceMappingCommand extends $Command<DeleteEventSourceMappingCommandInput, DeleteEventSourceMappingCommandOutput, LambdaClientResolvedConfig> {
     readonly input: DeleteEventSourceMappingCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteEventSourceMappingCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteEventSourceMappingCommandInput, DeleteEventSourceMappingCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/DeleteFunctionCodeSigningConfigCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
 import { DeleteFunctionCodeSigningConfigRequest } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link DeleteFunctionCodeSigningConfigCommand}.
  */
 export interface DeleteFunctionCodeSigningConfigCommandInput extends DeleteFunctionCodeSigningConfigRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteFunctionCodeSigningConfigCommand}.
  */
 export interface DeleteFunctionCodeSigningConfigCommandOutput extends __MetadataBearer {
 }
 /**
+ * @public
  * <p>Removes the code signing configuration from the function.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface DeleteFunctionCodeSigningConfigCommandOutput extends __Metadata
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteFunctionCodeSigningConfigCommandInput - {@link DeleteFunctionCodeSigningConfigCommandInput}
+ * @returns {@link DeleteFunctionCodeSigningConfigCommandOutput}
  * @see {@link DeleteFunctionCodeSigningConfigCommandInput} for command's `input` shape.
  * @see {@link DeleteFunctionCodeSigningConfigCommandOutput} for command's `response` shape.
  * @see {@link LambdaClientResolvedConfig | config} for LambdaClient's `config` shape.
@@ -52,11 +59,20 @@ export interface DeleteFunctionCodeSigningConfigCommandOutput extends __Metadata
 export declare class DeleteFunctionCodeSigningConfigCommand extends $Command<DeleteFunctionCodeSigningConfigCommandInput, DeleteFunctionCodeSigningConfigCommandOutput, LambdaClientResolvedConfig> {
     readonly input: DeleteFunctionCodeSigningConfigCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteFunctionCodeSigningConfigCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteFunctionCodeSigningConfigCommandInput, DeleteFunctionCodeSigningConfigCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
 import { DeleteFunctionRequest } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link DeleteFunctionCommand}.
  */
 export interface DeleteFunctionCommandInput extends DeleteFunctionRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteFunctionCommand}.
  */
 export interface DeleteFunctionCommandOutput extends __MetadataBearer {
 }
 /**
+ * @public
  * <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 and resources that invoke your function
@@ -28,6 +33,8 @@ export interface DeleteFunctionCommandOutput extends __MetadataBearer {
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteFunctionCommandInput - {@link DeleteFunctionCommandInput}
+ * @returns {@link DeleteFunctionCommandOutput}
  * @see {@link DeleteFunctionCommandInput} for command's `input` shape.
  * @see {@link DeleteFunctionCommandOutput} for command's `response` shape.
  * @see {@link LambdaClientResolvedConfig | config} for LambdaClient's `config` shape.
@@ -52,11 +59,20 @@ export interface DeleteFunctionCommandOutput extends __MetadataBearer {
 export declare class DeleteFunctionCommand extends $Command<DeleteFunctionCommandInput, DeleteFunctionCommandOutput, LambdaClientResolvedConfig> {
     readonly input: DeleteFunctionCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteFunctionCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteFunctionCommandInput, DeleteFunctionCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
 import { DeleteFunctionConcurrencyRequest } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link DeleteFunctionConcurrencyCommand}.
  */
 export interface DeleteFunctionConcurrencyCommandInput extends DeleteFunctionConcurrencyRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteFunctionConcurrencyCommand}.
  */
 export interface DeleteFunctionConcurrencyCommandOutput extends __MetadataBearer {
 }
 /**
+ * @public
  * <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.
@@ -25,6 +30,8 @@ export interface DeleteFunctionConcurrencyCommandOutput extends __MetadataBearer
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteFunctionConcurrencyCommandInput - {@link DeleteFunctionConcurrencyCommandInput}
+ * @returns {@link DeleteFunctionConcurrencyCommandOutput}
  * @see {@link DeleteFunctionConcurrencyCommandInput} for command's `input` shape.
  * @see {@link DeleteFunctionConcurrencyCommandOutput} for command's `response` shape.
  * @see {@link LambdaClientResolvedConfig | config} for LambdaClient's `config` shape.
@@ -49,11 +56,20 @@ export interface DeleteFunctionConcurrencyCommandOutput extends __MetadataBearer
 export declare class DeleteFunctionConcurrencyCommand extends $Command<DeleteFunctionConcurrencyCommandInput, DeleteFunctionConcurrencyCommandOutput, LambdaClientResolvedConfig> {
     readonly input: DeleteFunctionConcurrencyCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteFunctionConcurrencyCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteFunctionConcurrencyCommandInput, DeleteFunctionConcurrencyCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }