@aws-sdk/client-lambda 3.32.0 → 3.36.0

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

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

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

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

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

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

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

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

package/dist/types/commands/DeleteFunctionEventInvokeConfigCommand.d.ts

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

package/dist/types/commands/DeleteLayerVersionCommand.d.ts

@@ -1,37 +0,0 @@
-import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
-import { DeleteLayerVersionRequest } 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 DeleteLayerVersionCommandInput extends DeleteLayerVersionRequest {
-}
-export interface DeleteLayerVersionCommandOutput extends __MetadataBearer {
-}
-/**
- * <p>Deletes a version of an <a href="https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html">Lambda
- *         layer</a>. Deleted versions can no longer be viewed or added to functions. To avoid
- *       breaking functions, a copy of the version remains in Lambda until no functions refer to it.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LambdaClient, DeleteLayerVersionCommand } from "@aws-sdk/client-lambda"; // ES Modules import
- * // const { LambdaClient, DeleteLayerVersionCommand } = require("@aws-sdk/client-lambda"); // CommonJS import
- * const client = new LambdaClient(config);
- * const command = new DeleteLayerVersionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteLayerVersionCommandInput} for command's `input` shape.
- * @see {@link DeleteLayerVersionCommandOutput} for command's `response` shape.
- * @see {@link LambdaClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteLayerVersionCommand extends $Command<DeleteLayerVersionCommandInput, DeleteLayerVersionCommandOutput, LambdaClientResolvedConfig> {
-    readonly input: DeleteLayerVersionCommandInput;
-    constructor(input: DeleteLayerVersionCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteLayerVersionCommandInput, DeleteLayerVersionCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/DeleteProvisionedConcurrencyConfigCommand.d.ts

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

package/dist/types/commands/GetAccountSettingsCommand.d.ts

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

package/dist/types/commands/GetAliasCommand.d.ts

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

package/dist/types/commands/GetCodeSigningConfigCommand.d.ts

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

package/dist/types/commands/GetEventSourceMappingCommand.d.ts

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

package/dist/types/commands/GetFunctionCodeSigningConfigCommand.d.ts

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

package/dist/types/commands/GetFunctionCommand.d.ts

@@ -1,37 +0,0 @@
-import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
-import { GetFunctionRequest, GetFunctionResponse } 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 GetFunctionCommandInput extends GetFunctionRequest {
-}
-export interface GetFunctionCommandOutput extends GetFunctionResponse, __MetadataBearer {
-}
-/**
- * <p>Returns information about the function or function version, with a link to download the deployment package
- *       that's valid for 10 minutes. If you specify a function version, only details that are specific to that version are
- *       returned.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LambdaClient, GetFunctionCommand } from "@aws-sdk/client-lambda"; // ES Modules import
- * // const { LambdaClient, GetFunctionCommand } = require("@aws-sdk/client-lambda"); // CommonJS import
- * const client = new LambdaClient(config);
- * const command = new GetFunctionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetFunctionCommandInput} for command's `input` shape.
- * @see {@link GetFunctionCommandOutput} for command's `response` shape.
- * @see {@link LambdaClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class GetFunctionCommand extends $Command<GetFunctionCommandInput, GetFunctionCommandOutput, LambdaClientResolvedConfig> {
-    readonly input: GetFunctionCommandInput;
-    constructor(input: GetFunctionCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetFunctionCommandInput, GetFunctionCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/GetFunctionConcurrencyCommand.d.ts

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

package/dist/types/commands/GetFunctionConfigurationCommand.d.ts

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

package/dist/types/commands/GetFunctionEventInvokeConfigCommand.d.ts

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

package/dist/types/commands/GetLayerVersionByArnCommand.d.ts

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