@aws-sdk/client-lambda 3.32.0 → 3.36.0

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

@@ -1,37 +0,0 @@
-import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
-import { GetLayerVersionRequest, GetLayerVersionResponse } 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 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

@@ -1,36 +0,0 @@
-import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
-import { GetLayerVersionPolicyRequest, GetLayerVersionPolicyResponse } 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 GetLayerVersionPolicyCommandInput extends GetLayerVersionPolicyRequest {
-}
-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

@@ -1,35 +0,0 @@
-import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
-import { GetPolicyRequest, GetPolicyResponse } 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 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

@@ -1,35 +0,0 @@
-import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
-import { GetProvisionedConcurrencyConfigRequest, GetProvisionedConcurrencyConfigResponse } 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 GetProvisionedConcurrencyConfigCommandInput extends GetProvisionedConcurrencyConfigRequest {
-}
-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;
-}

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

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

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

@@ -1,61 +0,0 @@
-import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
-import { InvocationRequest, InvocationResponse } 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 InvokeCommandInput extends InvocationRequest {
-}
-export interface InvokeCommandOutput extends InvocationResponse, __MetadataBearer {
-}
-/**
- * <p>Invokes a Lambda function. You can invoke a function synchronously (and wait for the response), or
- *       asynchronously. To invoke a function asynchronously, set <code>InvocationType</code> to <code>Event</code>.</p>
- *
- *          <p>For <a href="https://docs.aws.amazon.com/lambda/latest/dg/invocation-sync.html">synchronous invocation</a>,
- *       details about the function response, including errors, are included in the response body and headers. For either
- *       invocation type, you can find more information in the <a href="https://docs.aws.amazon.com/lambda/latest/dg/monitoring-functions.html">execution log</a> and <a href="https://docs.aws.amazon.com/lambda/latest/dg/lambda-x-ray.html">trace</a>.</p>
- *
- *          <p>When an error occurs, your function may be invoked multiple times. Retry behavior varies by error type,
- *       client, event source, and invocation type. For example, if you invoke a function asynchronously and it returns an
- *       error, Lambda executes the function up to two more times. For more information, see <a href="https://docs.aws.amazon.com/lambda/latest/dg/retries-on-errors.html">Retry Behavior</a>.</p>
- *
- *          <p>For <a href="https://docs.aws.amazon.com/lambda/latest/dg/invocation-async.html">asynchronous invocation</a>,
- *       Lambda adds events to a queue before sending them to your function. If your function does not have enough capacity
- *       to keep up with the queue, events may be lost. Occasionally, your function may receive the same event multiple
- *       times, even if no error occurs. To retain events that were not processed, configure your function with a <a href="https://docs.aws.amazon.com/lambda/latest/dg/invocation-async.html#dlq">dead-letter queue</a>.</p>
- *
- *          <p>The status code in the API response doesn't reflect function errors. Error codes are reserved for errors that
- *       prevent your function from executing, such as permissions errors, <a href="https://docs.aws.amazon.com/lambda/latest/dg/limits.html">limit errors</a>, or issues with your function's code and configuration.
- *       For example, Lambda returns <code>TooManyRequestsException</code> if executing the function would cause you to
- *       exceed a concurrency limit at either the account level (<code>ConcurrentInvocationLimitExceeded</code>) or
- *       function level (<code>ReservedFunctionConcurrentInvocationLimitExceeded</code>).</p>
- *
- *          <p>For functions with a long timeout, your client might be disconnected during synchronous invocation while it
- *       waits for a response. Configure your HTTP client, SDK, firewall, proxy, or operating system to allow for long
- *       connections with timeout or keep-alive settings.</p>
- *
- *          <p>This operation requires permission for the <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/list_awslambda.html">lambda:InvokeFunction</a> action.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LambdaClient, InvokeCommand } from "@aws-sdk/client-lambda"; // ES Modules import
- * // const { LambdaClient, InvokeCommand } = require("@aws-sdk/client-lambda"); // CommonJS import
- * const client = new LambdaClient(config);
- * const command = new InvokeCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link InvokeCommandInput} for command's `input` shape.
- * @see {@link InvokeCommandOutput} for command's `response` shape.
- * @see {@link LambdaClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class InvokeCommand extends $Command<InvokeCommandInput, InvokeCommandOutput, LambdaClientResolvedConfig> {
-    readonly input: InvokeCommandInput;
-    constructor(input: InvokeCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<InvokeCommandInput, InvokeCommandOutput>;
-    private serialize;
-    private deserialize;
-}

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

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

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

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

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

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

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

@@ -1,36 +0,0 @@
-import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
-import { ListFunctionEventInvokeConfigsRequest, ListFunctionEventInvokeConfigsResponse } 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 ListFunctionEventInvokeConfigsCommandInput extends ListFunctionEventInvokeConfigsRequest {
-}
-export interface ListFunctionEventInvokeConfigsCommandOutput extends ListFunctionEventInvokeConfigsResponse, __MetadataBearer {
-}
-/**
- * <p>Retrieves a list of configurations for asynchronous invocation for a function.</p>
- *          <p>To configure options for asynchronous invocation, use <a>PutFunctionEventInvokeConfig</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LambdaClient, ListFunctionEventInvokeConfigsCommand } from "@aws-sdk/client-lambda"; // ES Modules import
- * // const { LambdaClient, ListFunctionEventInvokeConfigsCommand } = require("@aws-sdk/client-lambda"); // CommonJS import
- * const client = new LambdaClient(config);
- * const command = new ListFunctionEventInvokeConfigsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListFunctionEventInvokeConfigsCommandInput} for command's `input` shape.
- * @see {@link ListFunctionEventInvokeConfigsCommandOutput} for command's `response` shape.
- * @see {@link LambdaClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class ListFunctionEventInvokeConfigsCommand extends $Command<ListFunctionEventInvokeConfigsCommandInput, ListFunctionEventInvokeConfigsCommandOutput, LambdaClientResolvedConfig> {
-    readonly input: ListFunctionEventInvokeConfigsCommandInput;
-    constructor(input: ListFunctionEventInvokeConfigsCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListFunctionEventInvokeConfigsCommandInput, ListFunctionEventInvokeConfigsCommandOutput>;
-    private serialize;
-    private deserialize;
-}

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

@@ -1,36 +0,0 @@
-import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
-import { ListFunctionsByCodeSigningConfigRequest, ListFunctionsByCodeSigningConfigResponse } 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 ListFunctionsByCodeSigningConfigCommandInput extends ListFunctionsByCodeSigningConfigRequest {
-}
-export interface ListFunctionsByCodeSigningConfigCommandOutput extends ListFunctionsByCodeSigningConfigResponse, __MetadataBearer {
-}
-/**
- * <p>List the functions that use the specified code signing configuration. You can use this method prior to deleting a
- *       code signing configuration, to verify that no functions are using it.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LambdaClient, ListFunctionsByCodeSigningConfigCommand } from "@aws-sdk/client-lambda"; // ES Modules import
- * // const { LambdaClient, ListFunctionsByCodeSigningConfigCommand } = require("@aws-sdk/client-lambda"); // CommonJS import
- * const client = new LambdaClient(config);
- * const command = new ListFunctionsByCodeSigningConfigCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListFunctionsByCodeSigningConfigCommandInput} for command's `input` shape.
- * @see {@link ListFunctionsByCodeSigningConfigCommandOutput} for command's `response` shape.
- * @see {@link LambdaClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class ListFunctionsByCodeSigningConfigCommand extends $Command<ListFunctionsByCodeSigningConfigCommandInput, ListFunctionsByCodeSigningConfigCommandOutput, LambdaClientResolvedConfig> {
-    readonly input: ListFunctionsByCodeSigningConfigCommandInput;
-    constructor(input: ListFunctionsByCodeSigningConfigCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListFunctionsByCodeSigningConfigCommandInput, ListFunctionsByCodeSigningConfigCommandOutput>;
-    private serialize;
-    private deserialize;
-}

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

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

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

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

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

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

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

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