@aws-sdk/client-lambda 3.50.0 → 3.51.0

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
+import { DeleteCodeSigningConfigRequest, DeleteCodeSigningConfigResponse } from "../models/models_0";
+export interface DeleteCodeSigningConfigCommandInput extends DeleteCodeSigningConfigRequest {
+}
+export interface DeleteCodeSigningConfigCommandOutput extends DeleteCodeSigningConfigResponse, __MetadataBearer {
+}
+
+export declare class DeleteCodeSigningConfigCommand extends $Command<DeleteCodeSigningConfigCommandInput, DeleteCodeSigningConfigCommandOutput, LambdaClientResolvedConfig> {
+    readonly input: DeleteCodeSigningConfigCommandInput;
+    constructor(input: DeleteCodeSigningConfigCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteCodeSigningConfigCommandInput, DeleteCodeSigningConfigCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
+import { DeleteEventSourceMappingRequest, EventSourceMappingConfiguration } from "../models/models_0";
+export interface DeleteEventSourceMappingCommandInput extends DeleteEventSourceMappingRequest {
+}
+export interface DeleteEventSourceMappingCommandOutput extends EventSourceMappingConfiguration, __MetadataBearer {
+}
+
+export declare class DeleteEventSourceMappingCommand extends $Command<DeleteEventSourceMappingCommandInput, DeleteEventSourceMappingCommandOutput, LambdaClientResolvedConfig> {
+    readonly input: DeleteEventSourceMappingCommandInput;
+    constructor(input: DeleteEventSourceMappingCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteEventSourceMappingCommandInput, DeleteEventSourceMappingCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
+import { DeleteFunctionCodeSigningConfigRequest } from "../models/models_0";
+export interface DeleteFunctionCodeSigningConfigCommandInput extends DeleteFunctionCodeSigningConfigRequest {
+}
+export interface DeleteFunctionCodeSigningConfigCommandOutput extends __MetadataBearer {
+}
+
+export declare class DeleteFunctionCodeSigningConfigCommand extends $Command<DeleteFunctionCodeSigningConfigCommandInput, DeleteFunctionCodeSigningConfigCommandOutput, LambdaClientResolvedConfig> {
+    readonly input: DeleteFunctionCodeSigningConfigCommandInput;
+    constructor(input: DeleteFunctionCodeSigningConfigCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteFunctionCodeSigningConfigCommandInput, DeleteFunctionCodeSigningConfigCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
+import { DeleteFunctionRequest } from "../models/models_0";
+export interface DeleteFunctionCommandInput extends DeleteFunctionRequest {
+}
+export interface DeleteFunctionCommandOutput extends __MetadataBearer {
+}
+
+export declare class DeleteFunctionCommand extends $Command<DeleteFunctionCommandInput, DeleteFunctionCommandOutput, LambdaClientResolvedConfig> {
+    readonly input: DeleteFunctionCommandInput;
+    constructor(input: DeleteFunctionCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteFunctionCommandInput, DeleteFunctionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
+import { DeleteFunctionConcurrencyRequest } from "../models/models_0";
+export interface DeleteFunctionConcurrencyCommandInput extends DeleteFunctionConcurrencyRequest {
+}
+export interface DeleteFunctionConcurrencyCommandOutput extends __MetadataBearer {
+}
+
+export declare class DeleteFunctionConcurrencyCommand extends $Command<DeleteFunctionConcurrencyCommandInput, DeleteFunctionConcurrencyCommandOutput, LambdaClientResolvedConfig> {
+    readonly input: DeleteFunctionConcurrencyCommandInput;
+    constructor(input: DeleteFunctionConcurrencyCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteFunctionConcurrencyCommandInput, DeleteFunctionConcurrencyCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
+import { DeleteFunctionEventInvokeConfigRequest } from "../models/models_0";
+export interface DeleteFunctionEventInvokeConfigCommandInput extends DeleteFunctionEventInvokeConfigRequest {
+}
+export interface DeleteFunctionEventInvokeConfigCommandOutput extends __MetadataBearer {
+}
+
+export declare class DeleteFunctionEventInvokeConfigCommand extends $Command<DeleteFunctionEventInvokeConfigCommandInput, DeleteFunctionEventInvokeConfigCommandOutput, LambdaClientResolvedConfig> {
+    readonly input: DeleteFunctionEventInvokeConfigCommandInput;
+    constructor(input: DeleteFunctionEventInvokeConfigCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteFunctionEventInvokeConfigCommandInput, DeleteFunctionEventInvokeConfigCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
+import { DeleteLayerVersionRequest } from "../models/models_0";
+export interface DeleteLayerVersionCommandInput extends DeleteLayerVersionRequest {
+}
+export interface DeleteLayerVersionCommandOutput extends __MetadataBearer {
+}
+
+export declare class DeleteLayerVersionCommand extends $Command<DeleteLayerVersionCommandInput, DeleteLayerVersionCommandOutput, LambdaClientResolvedConfig> {
+    readonly input: DeleteLayerVersionCommandInput;
+    constructor(input: DeleteLayerVersionCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteLayerVersionCommandInput, DeleteLayerVersionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
+import { DeleteProvisionedConcurrencyConfigRequest } from "../models/models_0";
+export interface DeleteProvisionedConcurrencyConfigCommandInput extends DeleteProvisionedConcurrencyConfigRequest {
+}
+export interface DeleteProvisionedConcurrencyConfigCommandOutput extends __MetadataBearer {
+}
+
+export declare class DeleteProvisionedConcurrencyConfigCommand extends $Command<DeleteProvisionedConcurrencyConfigCommandInput, DeleteProvisionedConcurrencyConfigCommandOutput, LambdaClientResolvedConfig> {
+    readonly input: DeleteProvisionedConcurrencyConfigCommandInput;
+    constructor(input: DeleteProvisionedConcurrencyConfigCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteProvisionedConcurrencyConfigCommandInput, DeleteProvisionedConcurrencyConfigCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
+import { GetAccountSettingsRequest, GetAccountSettingsResponse } from "../models/models_0";
+export interface GetAccountSettingsCommandInput extends GetAccountSettingsRequest {
+}
+export interface GetAccountSettingsCommandOutput extends GetAccountSettingsResponse, __MetadataBearer {
+}
+
+export declare class GetAccountSettingsCommand extends $Command<GetAccountSettingsCommandInput, GetAccountSettingsCommandOutput, LambdaClientResolvedConfig> {
+    readonly input: GetAccountSettingsCommandInput;
+    constructor(input: GetAccountSettingsCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetAccountSettingsCommandInput, GetAccountSettingsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
+import { AliasConfiguration, GetAliasRequest } from "../models/models_0";
+export interface GetAliasCommandInput extends GetAliasRequest {
+}
+export interface GetAliasCommandOutput extends AliasConfiguration, __MetadataBearer {
+}
+
+export declare class GetAliasCommand extends $Command<GetAliasCommandInput, GetAliasCommandOutput, LambdaClientResolvedConfig> {
+    readonly input: GetAliasCommandInput;
+    constructor(input: GetAliasCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetAliasCommandInput, GetAliasCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
+import { GetCodeSigningConfigRequest, GetCodeSigningConfigResponse } from "../models/models_0";
+export interface GetCodeSigningConfigCommandInput extends GetCodeSigningConfigRequest {
+}
+export interface GetCodeSigningConfigCommandOutput extends GetCodeSigningConfigResponse, __MetadataBearer {
+}
+
+export declare class GetCodeSigningConfigCommand extends $Command<GetCodeSigningConfigCommandInput, GetCodeSigningConfigCommandOutput, LambdaClientResolvedConfig> {
+    readonly input: GetCodeSigningConfigCommandInput;
+    constructor(input: GetCodeSigningConfigCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetCodeSigningConfigCommandInput, GetCodeSigningConfigCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
+import { EventSourceMappingConfiguration, GetEventSourceMappingRequest } from "../models/models_0";
+export interface GetEventSourceMappingCommandInput extends GetEventSourceMappingRequest {
+}
+export interface GetEventSourceMappingCommandOutput extends EventSourceMappingConfiguration, __MetadataBearer {
+}
+
+export declare class GetEventSourceMappingCommand extends $Command<GetEventSourceMappingCommandInput, GetEventSourceMappingCommandOutput, LambdaClientResolvedConfig> {
+    readonly input: GetEventSourceMappingCommandInput;
+    constructor(input: GetEventSourceMappingCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetEventSourceMappingCommandInput, GetEventSourceMappingCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
+import { GetFunctionCodeSigningConfigRequest, GetFunctionCodeSigningConfigResponse } from "../models/models_0";
+export interface GetFunctionCodeSigningConfigCommandInput extends GetFunctionCodeSigningConfigRequest {
+}
+export interface GetFunctionCodeSigningConfigCommandOutput extends GetFunctionCodeSigningConfigResponse, __MetadataBearer {
+}
+
+export declare class GetFunctionCodeSigningConfigCommand extends $Command<GetFunctionCodeSigningConfigCommandInput, GetFunctionCodeSigningConfigCommandOutput, LambdaClientResolvedConfig> {
+    readonly input: GetFunctionCodeSigningConfigCommandInput;
+    constructor(input: GetFunctionCodeSigningConfigCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetFunctionCodeSigningConfigCommandInput, GetFunctionCodeSigningConfigCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
+import { GetFunctionRequest, GetFunctionResponse } from "../models/models_0";
+export interface GetFunctionCommandInput extends GetFunctionRequest {
+}
+export interface GetFunctionCommandOutput extends GetFunctionResponse, __MetadataBearer {
+}
+
+export declare class GetFunctionCommand extends $Command<GetFunctionCommandInput, GetFunctionCommandOutput, LambdaClientResolvedConfig> {
+    readonly input: GetFunctionCommandInput;
+    constructor(input: GetFunctionCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetFunctionCommandInput, GetFunctionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
+import { GetFunctionConcurrencyRequest, GetFunctionConcurrencyResponse } from "../models/models_0";
+export interface GetFunctionConcurrencyCommandInput extends GetFunctionConcurrencyRequest {
+}
+export interface GetFunctionConcurrencyCommandOutput extends GetFunctionConcurrencyResponse, __MetadataBearer {
+}
+
+export declare class GetFunctionConcurrencyCommand extends $Command<GetFunctionConcurrencyCommandInput, GetFunctionConcurrencyCommandOutput, LambdaClientResolvedConfig> {
+    readonly input: GetFunctionConcurrencyCommandInput;
+    constructor(input: GetFunctionConcurrencyCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetFunctionConcurrencyCommandInput, GetFunctionConcurrencyCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
+import { FunctionConfiguration, GetFunctionConfigurationRequest } from "../models/models_0";
+export interface GetFunctionConfigurationCommandInput extends GetFunctionConfigurationRequest {
+}
+export interface GetFunctionConfigurationCommandOutput extends FunctionConfiguration, __MetadataBearer {
+}
+
+export declare class GetFunctionConfigurationCommand extends $Command<GetFunctionConfigurationCommandInput, GetFunctionConfigurationCommandOutput, LambdaClientResolvedConfig> {
+    readonly input: GetFunctionConfigurationCommandInput;
+    constructor(input: GetFunctionConfigurationCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetFunctionConfigurationCommandInput, GetFunctionConfigurationCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
+import { FunctionEventInvokeConfig, GetFunctionEventInvokeConfigRequest } from "../models/models_0";
+export interface GetFunctionEventInvokeConfigCommandInput extends GetFunctionEventInvokeConfigRequest {
+}
+export interface GetFunctionEventInvokeConfigCommandOutput extends FunctionEventInvokeConfig, __MetadataBearer {
+}
+
+export declare class GetFunctionEventInvokeConfigCommand extends $Command<GetFunctionEventInvokeConfigCommandInput, GetFunctionEventInvokeConfigCommandOutput, LambdaClientResolvedConfig> {
+    readonly input: GetFunctionEventInvokeConfigCommandInput;
+    constructor(input: GetFunctionEventInvokeConfigCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetFunctionEventInvokeConfigCommandInput, GetFunctionEventInvokeConfigCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
+import { GetLayerVersionByArnRequest, GetLayerVersionResponse } from "../models/models_0";
+export interface GetLayerVersionByArnCommandInput extends GetLayerVersionByArnRequest {
+}
+export interface GetLayerVersionByArnCommandOutput extends GetLayerVersionResponse, __MetadataBearer {
+}
+
+export declare class GetLayerVersionByArnCommand extends $Command<GetLayerVersionByArnCommandInput, GetLayerVersionByArnCommandOutput, LambdaClientResolvedConfig> {
+    readonly input: GetLayerVersionByArnCommandInput;
+    constructor(input: GetLayerVersionByArnCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetLayerVersionByArnCommandInput, GetLayerVersionByArnCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
+import { GetLayerVersionRequest, GetLayerVersionResponse } from "../models/models_0";
+export interface GetLayerVersionCommandInput extends GetLayerVersionRequest {
+}
+export interface GetLayerVersionCommandOutput extends GetLayerVersionResponse, __MetadataBearer {
+}
+
+export declare class GetLayerVersionCommand extends $Command<GetLayerVersionCommandInput, GetLayerVersionCommandOutput, LambdaClientResolvedConfig> {
+    readonly input: GetLayerVersionCommandInput;
+    constructor(input: GetLayerVersionCommandInput);
+    
+    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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
+import { GetLayerVersionPolicyRequest, GetLayerVersionPolicyResponse } from "../models/models_0";
+export interface GetLayerVersionPolicyCommandInput extends GetLayerVersionPolicyRequest {
+}
+export interface GetLayerVersionPolicyCommandOutput extends GetLayerVersionPolicyResponse, __MetadataBearer {
+}
+
+export declare class GetLayerVersionPolicyCommand extends $Command<GetLayerVersionPolicyCommandInput, GetLayerVersionPolicyCommandOutput, LambdaClientResolvedConfig> {
+    readonly input: GetLayerVersionPolicyCommandInput;
+    constructor(input: GetLayerVersionPolicyCommandInput);
+    
+    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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
+import { GetPolicyRequest, GetPolicyResponse } from "../models/models_0";
+export interface GetPolicyCommandInput extends GetPolicyRequest {
+}
+export interface GetPolicyCommandOutput extends GetPolicyResponse, __MetadataBearer {
+}
+
+export declare class GetPolicyCommand extends $Command<GetPolicyCommandInput, GetPolicyCommandOutput, LambdaClientResolvedConfig> {
+    readonly input: GetPolicyCommandInput;
+    constructor(input: GetPolicyCommandInput);
+    
+    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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
+import { GetProvisionedConcurrencyConfigRequest, GetProvisionedConcurrencyConfigResponse } from "../models/models_0";
+export interface GetProvisionedConcurrencyConfigCommandInput extends GetProvisionedConcurrencyConfigRequest {
+}
+export interface GetProvisionedConcurrencyConfigCommandOutput extends GetProvisionedConcurrencyConfigResponse, __MetadataBearer {
+}
+
+export declare class GetProvisionedConcurrencyConfigCommand extends $Command<GetProvisionedConcurrencyConfigCommandInput, GetProvisionedConcurrencyConfigCommandOutput, LambdaClientResolvedConfig> {
+    readonly input: GetProvisionedConcurrencyConfigCommandInput;
+    constructor(input: GetProvisionedConcurrencyConfigCommandInput);
+    
+    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

@@ -0,0 +1,24 @@
+
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
+import { InvokeAsyncRequest, InvokeAsyncResponse } from "../models/models_0";
+declare type InvokeAsyncCommandInputType = Pick<InvokeAsyncRequest, Exclude<keyof InvokeAsyncRequest, "InvokeArgs">> & {
+    
+    InvokeArgs: InvokeAsyncRequest["InvokeArgs"] | string | Uint8Array | Buffer;
+};
+
+export interface InvokeAsyncCommandInput extends InvokeAsyncCommandInputType {
+}
+export interface InvokeAsyncCommandOutput extends InvokeAsyncResponse, __MetadataBearer {
+}
+
+export declare class InvokeAsyncCommand extends $Command<InvokeAsyncCommandInput, InvokeAsyncCommandOutput, LambdaClientResolvedConfig> {
+    readonly input: InvokeAsyncCommandInput;
+    constructor(input: InvokeAsyncCommandInput);
+    
+    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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
+import { InvocationRequest, InvocationResponse } from "../models/models_0";
+export interface InvokeCommandInput extends InvocationRequest {
+}
+export interface InvokeCommandOutput extends InvocationResponse, __MetadataBearer {
+}
+
+export declare class InvokeCommand extends $Command<InvokeCommandInput, InvokeCommandOutput, LambdaClientResolvedConfig> {
+    readonly input: InvokeCommandInput;
+    constructor(input: InvokeCommandInput);
+    
+    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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
+import { ListAliasesRequest, ListAliasesResponse } from "../models/models_0";
+export interface ListAliasesCommandInput extends ListAliasesRequest {
+}
+export interface ListAliasesCommandOutput extends ListAliasesResponse, __MetadataBearer {
+}
+
+export declare class ListAliasesCommand extends $Command<ListAliasesCommandInput, ListAliasesCommandOutput, LambdaClientResolvedConfig> {
+    readonly input: ListAliasesCommandInput;
+    constructor(input: ListAliasesCommandInput);
+    
+    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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
+import { ListCodeSigningConfigsRequest, ListCodeSigningConfigsResponse } from "../models/models_0";
+export interface ListCodeSigningConfigsCommandInput extends ListCodeSigningConfigsRequest {
+}
+export interface ListCodeSigningConfigsCommandOutput extends ListCodeSigningConfigsResponse, __MetadataBearer {
+}
+
+export declare class ListCodeSigningConfigsCommand extends $Command<ListCodeSigningConfigsCommandInput, ListCodeSigningConfigsCommandOutput, LambdaClientResolvedConfig> {
+    readonly input: ListCodeSigningConfigsCommandInput;
+    constructor(input: ListCodeSigningConfigsCommandInput);
+    
+    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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
+import { ListEventSourceMappingsRequest, ListEventSourceMappingsResponse } from "../models/models_0";
+export interface ListEventSourceMappingsCommandInput extends ListEventSourceMappingsRequest {
+}
+export interface ListEventSourceMappingsCommandOutput extends ListEventSourceMappingsResponse, __MetadataBearer {
+}
+
+export declare class ListEventSourceMappingsCommand extends $Command<ListEventSourceMappingsCommandInput, ListEventSourceMappingsCommandOutput, LambdaClientResolvedConfig> {
+    readonly input: ListEventSourceMappingsCommandInput;
+    constructor(input: ListEventSourceMappingsCommandInput);
+    
+    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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
+import { ListFunctionEventInvokeConfigsRequest, ListFunctionEventInvokeConfigsResponse } from "../models/models_0";
+export interface ListFunctionEventInvokeConfigsCommandInput extends ListFunctionEventInvokeConfigsRequest {
+}
+export interface ListFunctionEventInvokeConfigsCommandOutput extends ListFunctionEventInvokeConfigsResponse, __MetadataBearer {
+}
+
+export declare class ListFunctionEventInvokeConfigsCommand extends $Command<ListFunctionEventInvokeConfigsCommandInput, ListFunctionEventInvokeConfigsCommandOutput, LambdaClientResolvedConfig> {
+    readonly input: ListFunctionEventInvokeConfigsCommandInput;
+    constructor(input: ListFunctionEventInvokeConfigsCommandInput);
+    
+    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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
+import { ListFunctionsByCodeSigningConfigRequest, ListFunctionsByCodeSigningConfigResponse } from "../models/models_0";
+export interface ListFunctionsByCodeSigningConfigCommandInput extends ListFunctionsByCodeSigningConfigRequest {
+}
+export interface ListFunctionsByCodeSigningConfigCommandOutput extends ListFunctionsByCodeSigningConfigResponse, __MetadataBearer {
+}
+
+export declare class ListFunctionsByCodeSigningConfigCommand extends $Command<ListFunctionsByCodeSigningConfigCommandInput, ListFunctionsByCodeSigningConfigCommandOutput, LambdaClientResolvedConfig> {
+    readonly input: ListFunctionsByCodeSigningConfigCommandInput;
+    constructor(input: ListFunctionsByCodeSigningConfigCommandInput);
+    
+    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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
+import { ListFunctionsRequest, ListFunctionsResponse } from "../models/models_0";
+export interface ListFunctionsCommandInput extends ListFunctionsRequest {
+}
+export interface ListFunctionsCommandOutput extends ListFunctionsResponse, __MetadataBearer {
+}
+
+export declare class ListFunctionsCommand extends $Command<ListFunctionsCommandInput, ListFunctionsCommandOutput, LambdaClientResolvedConfig> {
+    readonly input: ListFunctionsCommandInput;
+    constructor(input: ListFunctionsCommandInput);
+    
+    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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
+import { ListLayerVersionsRequest, ListLayerVersionsResponse } from "../models/models_0";
+export interface ListLayerVersionsCommandInput extends ListLayerVersionsRequest {
+}
+export interface ListLayerVersionsCommandOutput extends ListLayerVersionsResponse, __MetadataBearer {
+}
+
+export declare class ListLayerVersionsCommand extends $Command<ListLayerVersionsCommandInput, ListLayerVersionsCommandOutput, LambdaClientResolvedConfig> {
+    readonly input: ListLayerVersionsCommandInput;
+    constructor(input: ListLayerVersionsCommandInput);
+    
+    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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LambdaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LambdaClient";
+import { ListLayersRequest, ListLayersResponse } from "../models/models_0";
+export interface ListLayersCommandInput extends ListLayersRequest {
+}
+export interface ListLayersCommandOutput extends ListLayersResponse, __MetadataBearer {
+}
+
+export declare class ListLayersCommand extends $Command<ListLayersCommandInput, ListLayersCommandOutput, LambdaClientResolvedConfig> {
+    readonly input: ListLayersCommandInput;
+    constructor(input: ListLayersCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LambdaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListLayersCommandInput, ListLayersCommandOutput>;
+    private serialize;
+    private deserialize;
+}