@aws-sdk/client-lambda 3.32.0 → 3.36.0

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

@@ -1,36 +0,0 @@
-import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
-import { ListTagsRequest, ListTagsResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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

@@ -1,36 +0,0 @@
-import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
-import { ListVersionsByFunctionRequest, ListVersionsByFunctionResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface ListVersionsByFunctionCommandInput extends ListVersionsByFunctionRequest {
-}
-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

@@ -1,38 +0,0 @@
-import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
-import { PublishLayerVersionRequest, PublishLayerVersionResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface PublishLayerVersionCommandInput extends PublishLayerVersionRequest {
-}
-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

@@ -1,43 +0,0 @@
-import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
-import { FunctionConfiguration, PublishVersionRequest } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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

@@ -1,36 +0,0 @@
-import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
-import { PutFunctionCodeSigningConfigRequest, PutFunctionCodeSigningConfigResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface PutFunctionCodeSigningConfigCommandInput extends PutFunctionCodeSigningConfigRequest {
-}
-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;
-}

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

@@ -1,43 +0,0 @@
-import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
-import { Concurrency, PutFunctionConcurrencyRequest } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface PutFunctionConcurrencyCommandInput extends PutFunctionConcurrencyRequest {
-}
-export interface PutFunctionConcurrencyCommandOutput extends Concurrency, __MetadataBearer {
-}
-/**
- * <p>Sets the maximum number of simultaneous executions for a function, and reserves capacity for that concurrency
- *       level.</p>
- *          <p>Concurrency settings apply to the function as a whole, including all published versions and the unpublished
- *       version. Reserving concurrency both ensures that your function has capacity to process the specified number of
- *       events simultaneously, and prevents it from scaling beyond that level. Use <a>GetFunction</a> to see
- *       the current setting for a function.</p>
- *          <p>Use <a>GetAccountSettings</a> to see your Regional concurrency limit. You can reserve concurrency
- *       for as many functions as you like, as long as you leave at least 100 simultaneous executions unreserved for
- *       functions that aren't configured with a per-function limit. For more information, see <a href="https://docs.aws.amazon.com/lambda/latest/dg/concurrent-executions.html">Managing Concurrency</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LambdaClient, PutFunctionConcurrencyCommand } from "@aws-sdk/client-lambda"; // ES Modules import
- * // const { LambdaClient, PutFunctionConcurrencyCommand } = require("@aws-sdk/client-lambda"); // CommonJS import
- * const client = new LambdaClient(config);
- * const command = new PutFunctionConcurrencyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutFunctionConcurrencyCommandInput} for command's `input` shape.
- * @see {@link PutFunctionConcurrencyCommandOutput} for command's `response` shape.
- * @see {@link LambdaClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class PutFunctionConcurrencyCommand extends $Command<PutFunctionConcurrencyCommandInput, PutFunctionConcurrencyCommandOutput, LambdaClientResolvedConfig> {
-    readonly input: PutFunctionConcurrencyCommandInput;
-    constructor(input: PutFunctionConcurrencyCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutFunctionConcurrencyCommandInput, PutFunctionConcurrencyCommandOutput>;
-    private serialize;
-    private deserialize;
-}

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

@@ -1,45 +0,0 @@
-import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
-import { FunctionEventInvokeConfig, PutFunctionEventInvokeConfigRequest } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface PutFunctionEventInvokeConfigCommandInput extends PutFunctionEventInvokeConfigRequest {
-}
-export interface PutFunctionEventInvokeConfigCommandOutput extends FunctionEventInvokeConfig, __MetadataBearer {
-}
-/**
- * <p>Configures options for <a href="https://docs.aws.amazon.com/lambda/latest/dg/invocation-async.html">asynchronous
- *         invocation</a> on a function, version, or alias. If a configuration already exists for a function, version,
- *       or alias, this operation overwrites it. If you exclude any settings, they are removed. To set one option without
- *       affecting existing settings for other options, use <a>UpdateFunctionEventInvokeConfig</a>.</p>
- *          <p>By default, Lambda retries an asynchronous invocation twice if the function returns an error. It retains
- *       events in a queue for up to six hours. When an event fails all processing attempts or stays in the asynchronous
- *       invocation queue for too long, Lambda discards it. To retain discarded events, configure a dead-letter queue with
- *         <a>UpdateFunctionConfiguration</a>.</p>
- *          <p>To send an invocation record to a queue, topic, function, or event bus, specify a <a href="https://docs.aws.amazon.com/lambda/latest/dg/invocation-async.html#invocation-async-destinations">destination</a>. You can configure separate destinations for successful invocations (on-success) and events
- *       that fail all processing attempts (on-failure). You can configure destinations in addition to or instead of a
- *       dead-letter queue.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LambdaClient, PutFunctionEventInvokeConfigCommand } from "@aws-sdk/client-lambda"; // ES Modules import
- * // const { LambdaClient, PutFunctionEventInvokeConfigCommand } = require("@aws-sdk/client-lambda"); // CommonJS import
- * const client = new LambdaClient(config);
- * const command = new PutFunctionEventInvokeConfigCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutFunctionEventInvokeConfigCommandInput} for command's `input` shape.
- * @see {@link PutFunctionEventInvokeConfigCommandOutput} for command's `response` shape.
- * @see {@link LambdaClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class PutFunctionEventInvokeConfigCommand extends $Command<PutFunctionEventInvokeConfigCommandInput, PutFunctionEventInvokeConfigCommandOutput, LambdaClientResolvedConfig> {
-    readonly input: PutFunctionEventInvokeConfigCommandInput;
-    constructor(input: PutFunctionEventInvokeConfigCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutFunctionEventInvokeConfigCommandInput, PutFunctionEventInvokeConfigCommandOutput>;
-    private serialize;
-    private deserialize;
-}

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,36 +0,0 @@
-import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
-import { UpdateCodeSigningConfigRequest, UpdateCodeSigningConfigResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface UpdateCodeSigningConfigCommandInput extends UpdateCodeSigningConfigRequest {
-}
-export interface UpdateCodeSigningConfigCommandOutput extends UpdateCodeSigningConfigResponse, __MetadataBearer {
-}
-/**
- * <p>Update the code signing configuration. Changes to the code signing configuration take effect the next time a
- *       user tries to deploy a code package to the function. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LambdaClient, UpdateCodeSigningConfigCommand } from "@aws-sdk/client-lambda"; // ES Modules import
- * // const { LambdaClient, UpdateCodeSigningConfigCommand } = require("@aws-sdk/client-lambda"); // CommonJS import
- * const client = new LambdaClient(config);
- * const command = new UpdateCodeSigningConfigCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateCodeSigningConfigCommandInput} for command's `input` shape.
- * @see {@link UpdateCodeSigningConfigCommandOutput} for command's `response` shape.
- * @see {@link LambdaClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class UpdateCodeSigningConfigCommand extends $Command<UpdateCodeSigningConfigCommandInput, UpdateCodeSigningConfigCommandOutput, LambdaClientResolvedConfig> {
-    readonly input: UpdateCodeSigningConfigCommandInput;
-    constructor(input: UpdateCodeSigningConfigCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateCodeSigningConfigCommandInput, UpdateCodeSigningConfigCommandOutput>;
-    private serialize;
-    private deserialize;
-}

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

@@ -1,58 +0,0 @@
-import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
-import { EventSourceMappingConfiguration, UpdateEventSourceMappingRequest } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface UpdateEventSourceMappingCommandInput extends UpdateEventSourceMappingRequest {
-}
-export interface UpdateEventSourceMappingCommandOutput extends EventSourceMappingConfiguration, __MetadataBearer {
-}
-/**
- * <p>Updates an event source mapping. You can change the function that Lambda invokes, or pause invocation and resume later from the same location.</p>
- *          <p>The following error handling options are only available for stream sources (DynamoDB and Kinesis):</p>
- *          <ul>
- *             <li>
- *                <p>
- *                   <code>BisectBatchOnFunctionError</code> - If the function returns an error, split the batch in two and retry.</p>
- *             </li>
- *             <li>
- *                <p>
- *                   <code>DestinationConfig</code> - Send discarded records to an Amazon SQS queue or Amazon SNS topic.</p>
- *             </li>
- *             <li>
- *                <p>
- *                   <code>MaximumRecordAgeInSeconds</code> - Discard records older than the specified age. The default value is infinite (-1). When set to infinite (-1), failed records are retried until the record expires</p>
- *             </li>
- *             <li>
- *                <p>
- *                   <code>MaximumRetryAttempts</code> - Discard records after the specified number of retries. The default value is infinite (-1). When set to infinite (-1), failed records are retried until the record expires.</p>
- *             </li>
- *             <li>
- *                <p>
- *                   <code>ParallelizationFactor</code> - Process multiple batches from each shard concurrently.</p>
- *             </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LambdaClient, UpdateEventSourceMappingCommand } from "@aws-sdk/client-lambda"; // ES Modules import
- * // const { LambdaClient, UpdateEventSourceMappingCommand } = require("@aws-sdk/client-lambda"); // CommonJS import
- * const client = new LambdaClient(config);
- * const command = new UpdateEventSourceMappingCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateEventSourceMappingCommandInput} for command's `input` shape.
- * @see {@link UpdateEventSourceMappingCommandOutput} for command's `response` shape.
- * @see {@link LambdaClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class UpdateEventSourceMappingCommand extends $Command<UpdateEventSourceMappingCommandInput, UpdateEventSourceMappingCommandOutput, LambdaClientResolvedConfig> {
-    readonly input: UpdateEventSourceMappingCommandInput;
-    constructor(input: UpdateEventSourceMappingCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateEventSourceMappingCommandInput, UpdateEventSourceMappingCommandOutput>;
-    private serialize;
-    private deserialize;
-}