working rss feed to nostr publish

node_modules/@aws-sdk/client-lambda/dist-es/Lambda.js

@@ -0,0 +1,139 @@
+import { createAggregatedClient } from "@smithy/smithy-client";
+import { AddLayerVersionPermissionCommand, } from "./commands/AddLayerVersionPermissionCommand";
+import { AddPermissionCommand, } from "./commands/AddPermissionCommand";
+import { CreateAliasCommand } from "./commands/CreateAliasCommand";
+import { CreateCodeSigningConfigCommand, } from "./commands/CreateCodeSigningConfigCommand";
+import { CreateEventSourceMappingCommand, } from "./commands/CreateEventSourceMappingCommand";
+import { CreateFunctionCommand, } from "./commands/CreateFunctionCommand";
+import { CreateFunctionUrlConfigCommand, } from "./commands/CreateFunctionUrlConfigCommand";
+import { DeleteAliasCommand } from "./commands/DeleteAliasCommand";
+import { DeleteCodeSigningConfigCommand, } from "./commands/DeleteCodeSigningConfigCommand";
+import { DeleteEventSourceMappingCommand, } from "./commands/DeleteEventSourceMappingCommand";
+import { DeleteFunctionCodeSigningConfigCommand, } from "./commands/DeleteFunctionCodeSigningConfigCommand";
+import { DeleteFunctionCommand, } from "./commands/DeleteFunctionCommand";
+import { DeleteFunctionConcurrencyCommand, } from "./commands/DeleteFunctionConcurrencyCommand";
+import { DeleteFunctionEventInvokeConfigCommand, } from "./commands/DeleteFunctionEventInvokeConfigCommand";
+import { DeleteFunctionUrlConfigCommand, } from "./commands/DeleteFunctionUrlConfigCommand";
+import { DeleteLayerVersionCommand, } from "./commands/DeleteLayerVersionCommand";
+import { DeleteProvisionedConcurrencyConfigCommand, } from "./commands/DeleteProvisionedConcurrencyConfigCommand";
+import { GetAccountSettingsCommand, } from "./commands/GetAccountSettingsCommand";
+import { GetAliasCommand } from "./commands/GetAliasCommand";
+import { GetCodeSigningConfigCommand, } from "./commands/GetCodeSigningConfigCommand";
+import { GetEventSourceMappingCommand, } from "./commands/GetEventSourceMappingCommand";
+import { GetFunctionCodeSigningConfigCommand, } from "./commands/GetFunctionCodeSigningConfigCommand";
+import { GetFunctionCommand } from "./commands/GetFunctionCommand";
+import { GetFunctionConcurrencyCommand, } from "./commands/GetFunctionConcurrencyCommand";
+import { GetFunctionConfigurationCommand, } from "./commands/GetFunctionConfigurationCommand";
+import { GetFunctionEventInvokeConfigCommand, } from "./commands/GetFunctionEventInvokeConfigCommand";
+import { GetFunctionUrlConfigCommand, } from "./commands/GetFunctionUrlConfigCommand";
+import { GetLayerVersionByArnCommand, } from "./commands/GetLayerVersionByArnCommand";
+import { GetLayerVersionCommand, } from "./commands/GetLayerVersionCommand";
+import { GetLayerVersionPolicyCommand, } from "./commands/GetLayerVersionPolicyCommand";
+import { GetPolicyCommand } from "./commands/GetPolicyCommand";
+import { GetProvisionedConcurrencyConfigCommand, } from "./commands/GetProvisionedConcurrencyConfigCommand";
+import { GetRuntimeManagementConfigCommand, } from "./commands/GetRuntimeManagementConfigCommand";
+import { InvokeAsyncCommand } from "./commands/InvokeAsyncCommand";
+import { InvokeCommand } from "./commands/InvokeCommand";
+import { InvokeWithResponseStreamCommand, } from "./commands/InvokeWithResponseStreamCommand";
+import { ListAliasesCommand } from "./commands/ListAliasesCommand";
+import { ListCodeSigningConfigsCommand, } from "./commands/ListCodeSigningConfigsCommand";
+import { ListEventSourceMappingsCommand, } from "./commands/ListEventSourceMappingsCommand";
+import { ListFunctionEventInvokeConfigsCommand, } from "./commands/ListFunctionEventInvokeConfigsCommand";
+import { ListFunctionsByCodeSigningConfigCommand, } from "./commands/ListFunctionsByCodeSigningConfigCommand";
+import { ListFunctionsCommand, } from "./commands/ListFunctionsCommand";
+import { ListFunctionUrlConfigsCommand, } from "./commands/ListFunctionUrlConfigsCommand";
+import { ListLayersCommand } from "./commands/ListLayersCommand";
+import { ListLayerVersionsCommand, } from "./commands/ListLayerVersionsCommand";
+import { ListProvisionedConcurrencyConfigsCommand, } from "./commands/ListProvisionedConcurrencyConfigsCommand";
+import { ListTagsCommand } from "./commands/ListTagsCommand";
+import { ListVersionsByFunctionCommand, } from "./commands/ListVersionsByFunctionCommand";
+import { PublishLayerVersionCommand, } from "./commands/PublishLayerVersionCommand";
+import { PublishVersionCommand, } from "./commands/PublishVersionCommand";
+import { PutFunctionCodeSigningConfigCommand, } from "./commands/PutFunctionCodeSigningConfigCommand";
+import { PutFunctionConcurrencyCommand, } from "./commands/PutFunctionConcurrencyCommand";
+import { PutFunctionEventInvokeConfigCommand, } from "./commands/PutFunctionEventInvokeConfigCommand";
+import { PutProvisionedConcurrencyConfigCommand, } from "./commands/PutProvisionedConcurrencyConfigCommand";
+import { PutRuntimeManagementConfigCommand, } from "./commands/PutRuntimeManagementConfigCommand";
+import { RemoveLayerVersionPermissionCommand, } from "./commands/RemoveLayerVersionPermissionCommand";
+import { RemovePermissionCommand, } from "./commands/RemovePermissionCommand";
+import { TagResourceCommand } from "./commands/TagResourceCommand";
+import { UntagResourceCommand, } from "./commands/UntagResourceCommand";
+import { UpdateAliasCommand } from "./commands/UpdateAliasCommand";
+import { UpdateCodeSigningConfigCommand, } from "./commands/UpdateCodeSigningConfigCommand";
+import { UpdateEventSourceMappingCommand, } from "./commands/UpdateEventSourceMappingCommand";
+import { UpdateFunctionCodeCommand, } from "./commands/UpdateFunctionCodeCommand";
+import { UpdateFunctionConfigurationCommand, } from "./commands/UpdateFunctionConfigurationCommand";
+import { UpdateFunctionEventInvokeConfigCommand, } from "./commands/UpdateFunctionEventInvokeConfigCommand";
+import { UpdateFunctionUrlConfigCommand, } from "./commands/UpdateFunctionUrlConfigCommand";
+import { LambdaClient } from "./LambdaClient";
+const commands = {
+    AddLayerVersionPermissionCommand,
+    AddPermissionCommand,
+    CreateAliasCommand,
+    CreateCodeSigningConfigCommand,
+    CreateEventSourceMappingCommand,
+    CreateFunctionCommand,
+    CreateFunctionUrlConfigCommand,
+    DeleteAliasCommand,
+    DeleteCodeSigningConfigCommand,
+    DeleteEventSourceMappingCommand,
+    DeleteFunctionCommand,
+    DeleteFunctionCodeSigningConfigCommand,
+    DeleteFunctionConcurrencyCommand,
+    DeleteFunctionEventInvokeConfigCommand,
+    DeleteFunctionUrlConfigCommand,
+    DeleteLayerVersionCommand,
+    DeleteProvisionedConcurrencyConfigCommand,
+    GetAccountSettingsCommand,
+    GetAliasCommand,
+    GetCodeSigningConfigCommand,
+    GetEventSourceMappingCommand,
+    GetFunctionCommand,
+    GetFunctionCodeSigningConfigCommand,
+    GetFunctionConcurrencyCommand,
+    GetFunctionConfigurationCommand,
+    GetFunctionEventInvokeConfigCommand,
+    GetFunctionUrlConfigCommand,
+    GetLayerVersionCommand,
+    GetLayerVersionByArnCommand,
+    GetLayerVersionPolicyCommand,
+    GetPolicyCommand,
+    GetProvisionedConcurrencyConfigCommand,
+    GetRuntimeManagementConfigCommand,
+    InvokeCommand,
+    InvokeAsyncCommand,
+    InvokeWithResponseStreamCommand,
+    ListAliasesCommand,
+    ListCodeSigningConfigsCommand,
+    ListEventSourceMappingsCommand,
+    ListFunctionEventInvokeConfigsCommand,
+    ListFunctionsCommand,
+    ListFunctionsByCodeSigningConfigCommand,
+    ListFunctionUrlConfigsCommand,
+    ListLayersCommand,
+    ListLayerVersionsCommand,
+    ListProvisionedConcurrencyConfigsCommand,
+    ListTagsCommand,
+    ListVersionsByFunctionCommand,
+    PublishLayerVersionCommand,
+    PublishVersionCommand,
+    PutFunctionCodeSigningConfigCommand,
+    PutFunctionConcurrencyCommand,
+    PutFunctionEventInvokeConfigCommand,
+    PutProvisionedConcurrencyConfigCommand,
+    PutRuntimeManagementConfigCommand,
+    RemoveLayerVersionPermissionCommand,
+    RemovePermissionCommand,
+    TagResourceCommand,
+    UntagResourceCommand,
+    UpdateAliasCommand,
+    UpdateCodeSigningConfigCommand,
+    UpdateEventSourceMappingCommand,
+    UpdateFunctionCodeCommand,
+    UpdateFunctionConfigurationCommand,
+    UpdateFunctionEventInvokeConfigCommand,
+    UpdateFunctionUrlConfigCommand,
+};
+export class Lambda extends LambdaClient {
+}
+createAggregatedClient(commands, Lambda);

node_modules/@aws-sdk/client-lambda/dist-es/LambdaClient.js

@@ -0,0 +1,41 @@
+import { getHostHeaderPlugin, resolveHostHeaderConfig, } from "@aws-sdk/middleware-host-header";
+import { getLoggerPlugin } from "@aws-sdk/middleware-logger";
+import { getRecursionDetectionPlugin } from "@aws-sdk/middleware-recursion-detection";
+import { getAwsAuthPlugin, resolveAwsAuthConfig, } from "@aws-sdk/middleware-signing";
+import { getUserAgentPlugin, resolveUserAgentConfig, } from "@aws-sdk/middleware-user-agent";
+import { resolveRegionConfig } from "@smithy/config-resolver";
+import { resolveEventStreamSerdeConfig, } from "@smithy/eventstream-serde-config-resolver";
+import { getContentLengthPlugin } from "@smithy/middleware-content-length";
+import { resolveEndpointConfig } from "@smithy/middleware-endpoint";
+import { getRetryPlugin, resolveRetryConfig } from "@smithy/middleware-retry";
+import { Client as __Client, } from "@smithy/smithy-client";
+import { resolveClientEndpointParameters, } from "./endpoint/EndpointParameters";
+import { getRuntimeConfig as __getRuntimeConfig } from "./runtimeConfig";
+import { resolveRuntimeExtensions } from "./runtimeExtensions";
+export { __Client };
+export class LambdaClient extends __Client {
+    constructor(...[configuration]) {
+        const _config_0 = __getRuntimeConfig(configuration || {});
+        const _config_1 = resolveClientEndpointParameters(_config_0);
+        const _config_2 = resolveRegionConfig(_config_1);
+        const _config_3 = resolveEndpointConfig(_config_2);
+        const _config_4 = resolveRetryConfig(_config_3);
+        const _config_5 = resolveHostHeaderConfig(_config_4);
+        const _config_6 = resolveAwsAuthConfig(_config_5);
+        const _config_7 = resolveUserAgentConfig(_config_6);
+        const _config_8 = resolveEventStreamSerdeConfig(_config_7);
+        const _config_9 = resolveRuntimeExtensions(_config_8, configuration?.extensions || []);
+        super(_config_9);
+        this.config = _config_9;
+        this.middlewareStack.use(getRetryPlugin(this.config));
+        this.middlewareStack.use(getContentLengthPlugin(this.config));
+        this.middlewareStack.use(getHostHeaderPlugin(this.config));
+        this.middlewareStack.use(getLoggerPlugin(this.config));
+        this.middlewareStack.use(getRecursionDetectionPlugin(this.config));
+        this.middlewareStack.use(getAwsAuthPlugin(this.config));
+        this.middlewareStack.use(getUserAgentPlugin(this.config));
+    }
+    destroy() {
+        super.destroy();
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/AddLayerVersionPermissionCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_AddLayerVersionPermissionCommand, se_AddLayerVersionPermissionCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class AddLayerVersionPermissionCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, AddLayerVersionPermissionCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "AddLayerVersionPermissionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "AddLayerVersionPermission",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_AddLayerVersionPermissionCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_AddLayerVersionPermissionCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/AddPermissionCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_AddPermissionCommand, se_AddPermissionCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class AddPermissionCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, AddPermissionCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "AddPermissionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "AddPermission",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_AddPermissionCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_AddPermissionCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/CreateAliasCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_CreateAliasCommand, se_CreateAliasCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class CreateAliasCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, CreateAliasCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "CreateAliasCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "CreateAlias",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_CreateAliasCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_CreateAliasCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/CreateCodeSigningConfigCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_CreateCodeSigningConfigCommand, se_CreateCodeSigningConfigCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class CreateCodeSigningConfigCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, CreateCodeSigningConfigCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "CreateCodeSigningConfigCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "CreateCodeSigningConfig",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_CreateCodeSigningConfigCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_CreateCodeSigningConfigCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/CreateEventSourceMappingCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_CreateEventSourceMappingCommand, se_CreateEventSourceMappingCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class CreateEventSourceMappingCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, CreateEventSourceMappingCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "CreateEventSourceMappingCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "CreateEventSourceMapping",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_CreateEventSourceMappingCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_CreateEventSourceMappingCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/CreateFunctionCommand.js

@@ -0,0 +1,48 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { CreateFunctionRequestFilterSensitiveLog, FunctionConfigurationFilterSensitiveLog, } from "../models/models_0";
+import { de_CreateFunctionCommand, se_CreateFunctionCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class CreateFunctionCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, CreateFunctionCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "CreateFunctionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: CreateFunctionRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: FunctionConfigurationFilterSensitiveLog,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "CreateFunction",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_CreateFunctionCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_CreateFunctionCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/CreateFunctionUrlConfigCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_CreateFunctionUrlConfigCommand, se_CreateFunctionUrlConfigCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class CreateFunctionUrlConfigCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, CreateFunctionUrlConfigCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "CreateFunctionUrlConfigCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "CreateFunctionUrlConfig",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_CreateFunctionUrlConfigCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_CreateFunctionUrlConfigCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/DeleteAliasCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_DeleteAliasCommand, se_DeleteAliasCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class DeleteAliasCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, DeleteAliasCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "DeleteAliasCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "DeleteAlias",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_DeleteAliasCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_DeleteAliasCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/DeleteCodeSigningConfigCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_DeleteCodeSigningConfigCommand, se_DeleteCodeSigningConfigCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class DeleteCodeSigningConfigCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, DeleteCodeSigningConfigCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "DeleteCodeSigningConfigCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "DeleteCodeSigningConfig",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_DeleteCodeSigningConfigCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_DeleteCodeSigningConfigCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/DeleteEventSourceMappingCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_DeleteEventSourceMappingCommand, se_DeleteEventSourceMappingCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class DeleteEventSourceMappingCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, DeleteEventSourceMappingCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "DeleteEventSourceMappingCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "DeleteEventSourceMapping",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_DeleteEventSourceMappingCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_DeleteEventSourceMappingCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/DeleteFunctionCodeSigningConfigCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_DeleteFunctionCodeSigningConfigCommand, se_DeleteFunctionCodeSigningConfigCommand, } from "../protocols/Aws_restJson1";
+export { $Command };
+export class DeleteFunctionCodeSigningConfigCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, DeleteFunctionCodeSigningConfigCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "DeleteFunctionCodeSigningConfigCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "DeleteFunctionCodeSigningConfig",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_DeleteFunctionCodeSigningConfigCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_DeleteFunctionCodeSigningConfigCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/DeleteFunctionCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_DeleteFunctionCommand, se_DeleteFunctionCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class DeleteFunctionCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, DeleteFunctionCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "DeleteFunctionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "DeleteFunction",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_DeleteFunctionCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_DeleteFunctionCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/DeleteFunctionConcurrencyCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_DeleteFunctionConcurrencyCommand, se_DeleteFunctionConcurrencyCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class DeleteFunctionConcurrencyCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, DeleteFunctionConcurrencyCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "DeleteFunctionConcurrencyCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "DeleteFunctionConcurrency",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_DeleteFunctionConcurrencyCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_DeleteFunctionConcurrencyCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/DeleteFunctionEventInvokeConfigCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_DeleteFunctionEventInvokeConfigCommand, se_DeleteFunctionEventInvokeConfigCommand, } from "../protocols/Aws_restJson1";
+export { $Command };
+export class DeleteFunctionEventInvokeConfigCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, DeleteFunctionEventInvokeConfigCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "DeleteFunctionEventInvokeConfigCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "DeleteFunctionEventInvokeConfig",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_DeleteFunctionEventInvokeConfigCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_DeleteFunctionEventInvokeConfigCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/DeleteFunctionUrlConfigCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_DeleteFunctionUrlConfigCommand, se_DeleteFunctionUrlConfigCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class DeleteFunctionUrlConfigCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, DeleteFunctionUrlConfigCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "DeleteFunctionUrlConfigCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "DeleteFunctionUrlConfig",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_DeleteFunctionUrlConfigCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_DeleteFunctionUrlConfigCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/DeleteLayerVersionCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_DeleteLayerVersionCommand, se_DeleteLayerVersionCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class DeleteLayerVersionCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, DeleteLayerVersionCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "DeleteLayerVersionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "DeleteLayerVersion",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_DeleteLayerVersionCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_DeleteLayerVersionCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/DeleteProvisionedConcurrencyConfigCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_DeleteProvisionedConcurrencyConfigCommand, se_DeleteProvisionedConcurrencyConfigCommand, } from "../protocols/Aws_restJson1";
+export { $Command };
+export class DeleteProvisionedConcurrencyConfigCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, DeleteProvisionedConcurrencyConfigCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "DeleteProvisionedConcurrencyConfigCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "DeleteProvisionedConcurrencyConfig",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_DeleteProvisionedConcurrencyConfigCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_DeleteProvisionedConcurrencyConfigCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/GetAccountSettingsCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_GetAccountSettingsCommand, se_GetAccountSettingsCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class GetAccountSettingsCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetAccountSettingsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "GetAccountSettingsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "GetAccountSettings",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_GetAccountSettingsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_GetAccountSettingsCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/GetAliasCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_GetAliasCommand, se_GetAliasCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class GetAliasCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetAliasCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "GetAliasCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "GetAlias",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_GetAliasCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_GetAliasCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/GetCodeSigningConfigCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_GetCodeSigningConfigCommand, se_GetCodeSigningConfigCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class GetCodeSigningConfigCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetCodeSigningConfigCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "GetCodeSigningConfigCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "GetCodeSigningConfig",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_GetCodeSigningConfigCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_GetCodeSigningConfigCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/GetEventSourceMappingCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_GetEventSourceMappingCommand, se_GetEventSourceMappingCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class GetEventSourceMappingCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetEventSourceMappingCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "GetEventSourceMappingCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "GetEventSourceMapping",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_GetEventSourceMappingCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_GetEventSourceMappingCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/GetFunctionCodeSigningConfigCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_GetFunctionCodeSigningConfigCommand, se_GetFunctionCodeSigningConfigCommand, } from "../protocols/Aws_restJson1";
+export { $Command };
+export class GetFunctionCodeSigningConfigCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetFunctionCodeSigningConfigCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "GetFunctionCodeSigningConfigCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "GetFunctionCodeSigningConfig",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_GetFunctionCodeSigningConfigCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_GetFunctionCodeSigningConfigCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/GetFunctionCommand.js

@@ -0,0 +1,48 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { GetFunctionResponseFilterSensitiveLog } from "../models/models_0";
+import { de_GetFunctionCommand, se_GetFunctionCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class GetFunctionCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetFunctionCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "GetFunctionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: GetFunctionResponseFilterSensitiveLog,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "GetFunction",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_GetFunctionCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_GetFunctionCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/GetFunctionConcurrencyCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_GetFunctionConcurrencyCommand, se_GetFunctionConcurrencyCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class GetFunctionConcurrencyCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetFunctionConcurrencyCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "GetFunctionConcurrencyCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "GetFunctionConcurrency",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_GetFunctionConcurrencyCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_GetFunctionConcurrencyCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/GetFunctionConfigurationCommand.js

@@ -0,0 +1,48 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { FunctionConfigurationFilterSensitiveLog, } from "../models/models_0";
+import { de_GetFunctionConfigurationCommand, se_GetFunctionConfigurationCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class GetFunctionConfigurationCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetFunctionConfigurationCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "GetFunctionConfigurationCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: FunctionConfigurationFilterSensitiveLog,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "GetFunctionConfiguration",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_GetFunctionConfigurationCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_GetFunctionConfigurationCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/GetFunctionEventInvokeConfigCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_GetFunctionEventInvokeConfigCommand, se_GetFunctionEventInvokeConfigCommand, } from "../protocols/Aws_restJson1";
+export { $Command };
+export class GetFunctionEventInvokeConfigCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetFunctionEventInvokeConfigCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "GetFunctionEventInvokeConfigCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "GetFunctionEventInvokeConfig",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_GetFunctionEventInvokeConfigCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_GetFunctionEventInvokeConfigCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/GetFunctionUrlConfigCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_GetFunctionUrlConfigCommand, se_GetFunctionUrlConfigCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class GetFunctionUrlConfigCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetFunctionUrlConfigCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "GetFunctionUrlConfigCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "GetFunctionUrlConfig",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_GetFunctionUrlConfigCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_GetFunctionUrlConfigCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/GetLayerVersionByArnCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_GetLayerVersionByArnCommand, se_GetLayerVersionByArnCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class GetLayerVersionByArnCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetLayerVersionByArnCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "GetLayerVersionByArnCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "GetLayerVersionByArn",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_GetLayerVersionByArnCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_GetLayerVersionByArnCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/GetLayerVersionCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_GetLayerVersionCommand, se_GetLayerVersionCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class GetLayerVersionCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetLayerVersionCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "GetLayerVersionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "GetLayerVersion",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_GetLayerVersionCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_GetLayerVersionCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/GetLayerVersionPolicyCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_GetLayerVersionPolicyCommand, se_GetLayerVersionPolicyCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class GetLayerVersionPolicyCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetLayerVersionPolicyCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "GetLayerVersionPolicyCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "GetLayerVersionPolicy",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_GetLayerVersionPolicyCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_GetLayerVersionPolicyCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/GetPolicyCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_GetPolicyCommand, se_GetPolicyCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class GetPolicyCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetPolicyCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "GetPolicyCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "GetPolicy",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_GetPolicyCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_GetPolicyCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/GetProvisionedConcurrencyConfigCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_GetProvisionedConcurrencyConfigCommand, se_GetProvisionedConcurrencyConfigCommand, } from "../protocols/Aws_restJson1";
+export { $Command };
+export class GetProvisionedConcurrencyConfigCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetProvisionedConcurrencyConfigCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "GetProvisionedConcurrencyConfigCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "GetProvisionedConcurrencyConfig",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_GetProvisionedConcurrencyConfigCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_GetProvisionedConcurrencyConfigCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/GetRuntimeManagementConfigCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_GetRuntimeManagementConfigCommand, se_GetRuntimeManagementConfigCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class GetRuntimeManagementConfigCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetRuntimeManagementConfigCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "GetRuntimeManagementConfigCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "GetRuntimeManagementConfig",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_GetRuntimeManagementConfigCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_GetRuntimeManagementConfigCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/InvokeAsyncCommand.js

@@ -0,0 +1,48 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { InvokeAsyncRequestFilterSensitiveLog } from "../models/models_0";
+import { de_InvokeAsyncCommand, se_InvokeAsyncCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class InvokeAsyncCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, InvokeAsyncCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "InvokeAsyncCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: InvokeAsyncRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "InvokeAsync",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_InvokeAsyncCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_InvokeAsyncCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/InvokeCommand.js

@@ -0,0 +1,48 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { InvocationRequestFilterSensitiveLog, InvocationResponseFilterSensitiveLog, } from "../models/models_0";
+import { de_InvokeCommand, se_InvokeCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class InvokeCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, InvokeCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "InvokeCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: InvocationRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: InvocationResponseFilterSensitiveLog,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "Invoke",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_InvokeCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_InvokeCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/InvokeWithResponseStreamCommand.js

@@ -0,0 +1,48 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { InvokeWithResponseStreamRequestFilterSensitiveLog, InvokeWithResponseStreamResponseFilterSensitiveLog, } from "../models/models_0";
+import { de_InvokeWithResponseStreamCommand, se_InvokeWithResponseStreamCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class InvokeWithResponseStreamCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, InvokeWithResponseStreamCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "InvokeWithResponseStreamCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: InvokeWithResponseStreamRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: InvokeWithResponseStreamResponseFilterSensitiveLog,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "InvokeWithResponseStream",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_InvokeWithResponseStreamCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_InvokeWithResponseStreamCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/ListAliasesCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_ListAliasesCommand, se_ListAliasesCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class ListAliasesCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, ListAliasesCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "ListAliasesCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "ListAliases",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_ListAliasesCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_ListAliasesCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/ListCodeSigningConfigsCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_ListCodeSigningConfigsCommand, se_ListCodeSigningConfigsCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class ListCodeSigningConfigsCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, ListCodeSigningConfigsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "ListCodeSigningConfigsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "ListCodeSigningConfigs",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_ListCodeSigningConfigsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_ListCodeSigningConfigsCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/ListEventSourceMappingsCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_ListEventSourceMappingsCommand, se_ListEventSourceMappingsCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class ListEventSourceMappingsCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, ListEventSourceMappingsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "ListEventSourceMappingsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "ListEventSourceMappings",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_ListEventSourceMappingsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_ListEventSourceMappingsCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/ListFunctionEventInvokeConfigsCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_ListFunctionEventInvokeConfigsCommand, se_ListFunctionEventInvokeConfigsCommand, } from "../protocols/Aws_restJson1";
+export { $Command };
+export class ListFunctionEventInvokeConfigsCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, ListFunctionEventInvokeConfigsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "ListFunctionEventInvokeConfigsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "ListFunctionEventInvokeConfigs",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_ListFunctionEventInvokeConfigsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_ListFunctionEventInvokeConfigsCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/ListFunctionUrlConfigsCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_ListFunctionUrlConfigsCommand, se_ListFunctionUrlConfigsCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class ListFunctionUrlConfigsCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, ListFunctionUrlConfigsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "ListFunctionUrlConfigsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "ListFunctionUrlConfigs",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_ListFunctionUrlConfigsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_ListFunctionUrlConfigsCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/ListFunctionsByCodeSigningConfigCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_ListFunctionsByCodeSigningConfigCommand, se_ListFunctionsByCodeSigningConfigCommand, } from "../protocols/Aws_restJson1";
+export { $Command };
+export class ListFunctionsByCodeSigningConfigCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, ListFunctionsByCodeSigningConfigCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "ListFunctionsByCodeSigningConfigCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "ListFunctionsByCodeSigningConfig",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_ListFunctionsByCodeSigningConfigCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_ListFunctionsByCodeSigningConfigCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/ListFunctionsCommand.js

@@ -0,0 +1,48 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { ListFunctionsResponseFilterSensitiveLog, } from "../models/models_0";
+import { de_ListFunctionsCommand, se_ListFunctionsCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class ListFunctionsCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, ListFunctionsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "ListFunctionsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: ListFunctionsResponseFilterSensitiveLog,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "ListFunctions",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_ListFunctionsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_ListFunctionsCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/ListLayerVersionsCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_ListLayerVersionsCommand, se_ListLayerVersionsCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class ListLayerVersionsCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, ListLayerVersionsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "ListLayerVersionsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "ListLayerVersions",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_ListLayerVersionsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_ListLayerVersionsCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/ListLayersCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_ListLayersCommand, se_ListLayersCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class ListLayersCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, ListLayersCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "ListLayersCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "ListLayers",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_ListLayersCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_ListLayersCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/ListProvisionedConcurrencyConfigsCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_ListProvisionedConcurrencyConfigsCommand, se_ListProvisionedConcurrencyConfigsCommand, } from "../protocols/Aws_restJson1";
+export { $Command };
+export class ListProvisionedConcurrencyConfigsCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, ListProvisionedConcurrencyConfigsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "ListProvisionedConcurrencyConfigsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "ListProvisionedConcurrencyConfigs",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_ListProvisionedConcurrencyConfigsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_ListProvisionedConcurrencyConfigsCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/ListTagsCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_ListTagsCommand, se_ListTagsCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class ListTagsCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, ListTagsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "ListTagsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "ListTags",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_ListTagsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_ListTagsCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/ListVersionsByFunctionCommand.js

@@ -0,0 +1,48 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { ListVersionsByFunctionResponseFilterSensitiveLog, } from "../models/models_0";
+import { de_ListVersionsByFunctionCommand, se_ListVersionsByFunctionCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class ListVersionsByFunctionCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, ListVersionsByFunctionCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "ListVersionsByFunctionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: ListVersionsByFunctionResponseFilterSensitiveLog,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "ListVersionsByFunction",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_ListVersionsByFunctionCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_ListVersionsByFunctionCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/PublishLayerVersionCommand.js

@@ -0,0 +1,48 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { PublishLayerVersionRequestFilterSensitiveLog, } from "../models/models_0";
+import { de_PublishLayerVersionCommand, se_PublishLayerVersionCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class PublishLayerVersionCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, PublishLayerVersionCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "PublishLayerVersionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: PublishLayerVersionRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "PublishLayerVersion",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_PublishLayerVersionCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_PublishLayerVersionCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/PublishVersionCommand.js

@@ -0,0 +1,48 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { FunctionConfigurationFilterSensitiveLog, } from "../models/models_0";
+import { de_PublishVersionCommand, se_PublishVersionCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class PublishVersionCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, PublishVersionCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "PublishVersionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: FunctionConfigurationFilterSensitiveLog,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "PublishVersion",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_PublishVersionCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_PublishVersionCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/PutFunctionCodeSigningConfigCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_PutFunctionCodeSigningConfigCommand, se_PutFunctionCodeSigningConfigCommand, } from "../protocols/Aws_restJson1";
+export { $Command };
+export class PutFunctionCodeSigningConfigCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, PutFunctionCodeSigningConfigCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "PutFunctionCodeSigningConfigCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "PutFunctionCodeSigningConfig",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_PutFunctionCodeSigningConfigCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_PutFunctionCodeSigningConfigCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/PutFunctionConcurrencyCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_PutFunctionConcurrencyCommand, se_PutFunctionConcurrencyCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class PutFunctionConcurrencyCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, PutFunctionConcurrencyCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "PutFunctionConcurrencyCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "PutFunctionConcurrency",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_PutFunctionConcurrencyCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_PutFunctionConcurrencyCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/PutFunctionEventInvokeConfigCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_PutFunctionEventInvokeConfigCommand, se_PutFunctionEventInvokeConfigCommand, } from "../protocols/Aws_restJson1";
+export { $Command };
+export class PutFunctionEventInvokeConfigCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, PutFunctionEventInvokeConfigCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "PutFunctionEventInvokeConfigCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "PutFunctionEventInvokeConfig",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_PutFunctionEventInvokeConfigCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_PutFunctionEventInvokeConfigCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/PutProvisionedConcurrencyConfigCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_PutProvisionedConcurrencyConfigCommand, se_PutProvisionedConcurrencyConfigCommand, } from "../protocols/Aws_restJson1";
+export { $Command };
+export class PutProvisionedConcurrencyConfigCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, PutProvisionedConcurrencyConfigCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "PutProvisionedConcurrencyConfigCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "PutProvisionedConcurrencyConfig",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_PutProvisionedConcurrencyConfigCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_PutProvisionedConcurrencyConfigCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/PutRuntimeManagementConfigCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_PutRuntimeManagementConfigCommand, se_PutRuntimeManagementConfigCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class PutRuntimeManagementConfigCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, PutRuntimeManagementConfigCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "PutRuntimeManagementConfigCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "PutRuntimeManagementConfig",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_PutRuntimeManagementConfigCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_PutRuntimeManagementConfigCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/RemoveLayerVersionPermissionCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_RemoveLayerVersionPermissionCommand, se_RemoveLayerVersionPermissionCommand, } from "../protocols/Aws_restJson1";
+export { $Command };
+export class RemoveLayerVersionPermissionCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, RemoveLayerVersionPermissionCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "RemoveLayerVersionPermissionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "RemoveLayerVersionPermission",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_RemoveLayerVersionPermissionCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_RemoveLayerVersionPermissionCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/RemovePermissionCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_RemovePermissionCommand, se_RemovePermissionCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class RemovePermissionCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, RemovePermissionCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "RemovePermissionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "RemovePermission",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_RemovePermissionCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_RemovePermissionCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/TagResourceCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_TagResourceCommand, se_TagResourceCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class TagResourceCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, TagResourceCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "TagResourceCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "TagResource",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_TagResourceCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_TagResourceCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/UntagResourceCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_UntagResourceCommand, se_UntagResourceCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class UntagResourceCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, UntagResourceCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "UntagResourceCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "UntagResource",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_UntagResourceCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_UntagResourceCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/UpdateAliasCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_UpdateAliasCommand, se_UpdateAliasCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class UpdateAliasCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, UpdateAliasCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "UpdateAliasCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "UpdateAlias",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_UpdateAliasCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_UpdateAliasCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/UpdateCodeSigningConfigCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_UpdateCodeSigningConfigCommand, se_UpdateCodeSigningConfigCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class UpdateCodeSigningConfigCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, UpdateCodeSigningConfigCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "UpdateCodeSigningConfigCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "UpdateCodeSigningConfig",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_UpdateCodeSigningConfigCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_UpdateCodeSigningConfigCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/UpdateEventSourceMappingCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_UpdateEventSourceMappingCommand, se_UpdateEventSourceMappingCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class UpdateEventSourceMappingCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, UpdateEventSourceMappingCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "UpdateEventSourceMappingCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "UpdateEventSourceMapping",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_UpdateEventSourceMappingCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_UpdateEventSourceMappingCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/UpdateFunctionCodeCommand.js

@@ -0,0 +1,48 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { FunctionConfigurationFilterSensitiveLog, UpdateFunctionCodeRequestFilterSensitiveLog, } from "../models/models_0";
+import { de_UpdateFunctionCodeCommand, se_UpdateFunctionCodeCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class UpdateFunctionCodeCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, UpdateFunctionCodeCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "UpdateFunctionCodeCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: UpdateFunctionCodeRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: FunctionConfigurationFilterSensitiveLog,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "UpdateFunctionCode",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_UpdateFunctionCodeCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_UpdateFunctionCodeCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/UpdateFunctionConfigurationCommand.js

@@ -0,0 +1,48 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { FunctionConfigurationFilterSensitiveLog, UpdateFunctionConfigurationRequestFilterSensitiveLog, } from "../models/models_0";
+import { de_UpdateFunctionConfigurationCommand, se_UpdateFunctionConfigurationCommand, } from "../protocols/Aws_restJson1";
+export { $Command };
+export class UpdateFunctionConfigurationCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, UpdateFunctionConfigurationCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "UpdateFunctionConfigurationCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: UpdateFunctionConfigurationRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: FunctionConfigurationFilterSensitiveLog,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "UpdateFunctionConfiguration",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_UpdateFunctionConfigurationCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_UpdateFunctionConfigurationCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/UpdateFunctionEventInvokeConfigCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_UpdateFunctionEventInvokeConfigCommand, se_UpdateFunctionEventInvokeConfigCommand, } from "../protocols/Aws_restJson1";
+export { $Command };
+export class UpdateFunctionEventInvokeConfigCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, UpdateFunctionEventInvokeConfigCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "UpdateFunctionEventInvokeConfigCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "UpdateFunctionEventInvokeConfig",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_UpdateFunctionEventInvokeConfigCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_UpdateFunctionEventInvokeConfigCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/UpdateFunctionUrlConfigCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_UpdateFunctionUrlConfigCommand, se_UpdateFunctionUrlConfigCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class UpdateFunctionUrlConfigCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, UpdateFunctionUrlConfigCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "LambdaClient";
+        const commandName = "UpdateFunctionUrlConfigCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSGirApiService",
+                operation: "UpdateFunctionUrlConfig",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_UpdateFunctionUrlConfigCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_UpdateFunctionUrlConfigCommand(output, context);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/commands/index.js

@@ -0,0 +1,66 @@
+export * from "./AddLayerVersionPermissionCommand";
+export * from "./AddPermissionCommand";
+export * from "./CreateAliasCommand";
+export * from "./CreateCodeSigningConfigCommand";
+export * from "./CreateEventSourceMappingCommand";
+export * from "./CreateFunctionCommand";
+export * from "./CreateFunctionUrlConfigCommand";
+export * from "./DeleteAliasCommand";
+export * from "./DeleteCodeSigningConfigCommand";
+export * from "./DeleteEventSourceMappingCommand";
+export * from "./DeleteFunctionCodeSigningConfigCommand";
+export * from "./DeleteFunctionCommand";
+export * from "./DeleteFunctionConcurrencyCommand";
+export * from "./DeleteFunctionEventInvokeConfigCommand";
+export * from "./DeleteFunctionUrlConfigCommand";
+export * from "./DeleteLayerVersionCommand";
+export * from "./DeleteProvisionedConcurrencyConfigCommand";
+export * from "./GetAccountSettingsCommand";
+export * from "./GetAliasCommand";
+export * from "./GetCodeSigningConfigCommand";
+export * from "./GetEventSourceMappingCommand";
+export * from "./GetFunctionCodeSigningConfigCommand";
+export * from "./GetFunctionCommand";
+export * from "./GetFunctionConcurrencyCommand";
+export * from "./GetFunctionConfigurationCommand";
+export * from "./GetFunctionEventInvokeConfigCommand";
+export * from "./GetFunctionUrlConfigCommand";
+export * from "./GetLayerVersionByArnCommand";
+export * from "./GetLayerVersionCommand";
+export * from "./GetLayerVersionPolicyCommand";
+export * from "./GetPolicyCommand";
+export * from "./GetProvisionedConcurrencyConfigCommand";
+export * from "./GetRuntimeManagementConfigCommand";
+export * from "./InvokeAsyncCommand";
+export * from "./InvokeCommand";
+export * from "./InvokeWithResponseStreamCommand";
+export * from "./ListAliasesCommand";
+export * from "./ListCodeSigningConfigsCommand";
+export * from "./ListEventSourceMappingsCommand";
+export * from "./ListFunctionEventInvokeConfigsCommand";
+export * from "./ListFunctionUrlConfigsCommand";
+export * from "./ListFunctionsByCodeSigningConfigCommand";
+export * from "./ListFunctionsCommand";
+export * from "./ListLayerVersionsCommand";
+export * from "./ListLayersCommand";
+export * from "./ListProvisionedConcurrencyConfigsCommand";
+export * from "./ListTagsCommand";
+export * from "./ListVersionsByFunctionCommand";
+export * from "./PublishLayerVersionCommand";
+export * from "./PublishVersionCommand";
+export * from "./PutFunctionCodeSigningConfigCommand";
+export * from "./PutFunctionConcurrencyCommand";
+export * from "./PutFunctionEventInvokeConfigCommand";
+export * from "./PutProvisionedConcurrencyConfigCommand";
+export * from "./PutRuntimeManagementConfigCommand";
+export * from "./RemoveLayerVersionPermissionCommand";
+export * from "./RemovePermissionCommand";
+export * from "./TagResourceCommand";
+export * from "./UntagResourceCommand";
+export * from "./UpdateAliasCommand";
+export * from "./UpdateCodeSigningConfigCommand";
+export * from "./UpdateEventSourceMappingCommand";
+export * from "./UpdateFunctionCodeCommand";
+export * from "./UpdateFunctionConfigurationCommand";
+export * from "./UpdateFunctionEventInvokeConfigCommand";
+export * from "./UpdateFunctionUrlConfigCommand";

node_modules/@aws-sdk/client-lambda/dist-es/endpoint/EndpointParameters.js

@@ -0,0 +1,8 @@
+export const resolveClientEndpointParameters = (options) => {
+    return {
+        ...options,
+        useDualstackEndpoint: options.useDualstackEndpoint ?? false,
+        useFipsEndpoint: options.useFipsEndpoint ?? false,
+        defaultSigningName: "lambda",
+    };
+};

node_modules/@aws-sdk/client-lambda/dist-es/endpoint/endpointResolver.js

@@ -0,0 +1,8 @@
+import { resolveEndpoint } from "@smithy/util-endpoints";
+import { ruleSet } from "./ruleset";
+export const defaultEndpointResolver = (endpointParams, context = {}) => {
+    return resolveEndpoint(ruleSet, {
+        endpointParams: endpointParams,
+        logger: context.logger,
+    });
+};

node_modules/@aws-sdk/client-lambda/dist-es/endpoint/ruleset.js

@@ -0,0 +1,4 @@
+const s = "required", t = "fn", u = "argv", v = "ref";
+const a = true, b = "isSet", c = "booleanEquals", d = "error", e = "endpoint", f = "tree", g = "PartitionResult", h = { [s]: false, "type": "String" }, i = { [s]: true, "default": false, "type": "Boolean" }, j = { [v]: "Endpoint" }, k = { [t]: c, [u]: [{ [v]: "UseFIPS" }, true] }, l = { [t]: c, [u]: [{ [v]: "UseDualStack" }, true] }, m = {}, n = { [t]: "getAttr", [u]: [{ [v]: g }, "supportsFIPS"] }, o = { [t]: c, [u]: [true, { [t]: "getAttr", [u]: [{ [v]: g }, "supportsDualStack"] }] }, p = [k], q = [l], r = [{ [v]: "Region" }];
+const _data = { version: "1.0", parameters: { Region: h, UseDualStack: i, UseFIPS: i, Endpoint: h }, rules: [{ conditions: [{ [t]: b, [u]: [j] }], rules: [{ conditions: p, error: "Invalid Configuration: FIPS and custom endpoint are not supported", type: d }, { conditions: q, error: "Invalid Configuration: Dualstack and custom endpoint are not supported", type: d }, { endpoint: { url: j, properties: m, headers: m }, type: e }], type: f }, { conditions: [{ [t]: b, [u]: r }], rules: [{ conditions: [{ [t]: "aws.partition", [u]: r, assign: g }], rules: [{ conditions: [k, l], rules: [{ conditions: [{ [t]: c, [u]: [a, n] }, o], rules: [{ endpoint: { url: "https://lambda-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: m, headers: m }, type: e }], type: f }, { error: "FIPS and DualStack are enabled, but this partition does not support one or both", type: d }], type: f }, { conditions: p, rules: [{ conditions: [{ [t]: c, [u]: [n, a] }], rules: [{ endpoint: { url: "https://lambda-fips.{Region}.{PartitionResult#dnsSuffix}", properties: m, headers: m }, type: e }], type: f }, { error: "FIPS is enabled but this partition does not support FIPS", type: d }], type: f }, { conditions: q, rules: [{ conditions: [o], rules: [{ endpoint: { url: "https://lambda.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: m, headers: m }, type: e }], type: f }, { error: "DualStack is enabled but this partition does not support DualStack", type: d }], type: f }, { endpoint: { url: "https://lambda.{Region}.{PartitionResult#dnsSuffix}", properties: m, headers: m }, type: e }], type: f }], type: f }, { error: "Invalid Configuration: Missing Region", type: d }] };
+export const ruleSet = _data;

node_modules/@aws-sdk/client-lambda/dist-es/extensionConfiguration.js

@@ -0,0 +1 @@
+export {};

node_modules/@aws-sdk/client-lambda/dist-es/index.js

@@ -0,0 +1,8 @@
+export * from "./LambdaClient";
+export * from "./Lambda";
+export * from "./commands";
+export * from "./pagination";
+export * from "./waiters";
+export * from "./models";
+import "@aws-sdk/util-endpoints";
+export { LambdaServiceException } from "./models/LambdaServiceException";

node_modules/@aws-sdk/client-lambda/dist-es/models/LambdaServiceException.js

@@ -0,0 +1,8 @@
+import { ServiceException as __ServiceException, } from "@smithy/smithy-client";
+export { __ServiceException };
+export class LambdaServiceException extends __ServiceException {
+    constructor(options) {
+        super(options);
+        Object.setPrototypeOf(this, LambdaServiceException.prototype);
+    }
+}

node_modules/@aws-sdk/client-lambda/dist-es/models/index.js

@@ -0,0 +1 @@
+export * from "./models_0";

node_modules/@aws-sdk/client-lambda/dist-es/models/models_0.js

@@ -0,0 +1,849 @@
+import { SENSITIVE_STRING } from "@smithy/smithy-client";
+import { LambdaServiceException as __BaseException } from "./LambdaServiceException";
+export class InvalidParameterValueException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "InvalidParameterValueException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "InvalidParameterValueException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, InvalidParameterValueException.prototype);
+        this.Type = opts.Type;
+    }
+}
+export class PolicyLengthExceededException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "PolicyLengthExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "PolicyLengthExceededException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, PolicyLengthExceededException.prototype);
+        this.Type = opts.Type;
+    }
+}
+export class PreconditionFailedException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "PreconditionFailedException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "PreconditionFailedException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, PreconditionFailedException.prototype);
+        this.Type = opts.Type;
+    }
+}
+export class ResourceConflictException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ResourceConflictException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ResourceConflictException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ResourceConflictException.prototype);
+        this.Type = opts.Type;
+    }
+}
+export class ResourceNotFoundException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ResourceNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ResourceNotFoundException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
+        this.Type = opts.Type;
+        this.Message = opts.Message;
+    }
+}
+export class ServiceException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ServiceException",
+            $fault: "server",
+            ...opts,
+        });
+        this.name = "ServiceException";
+        this.$fault = "server";
+        Object.setPrototypeOf(this, ServiceException.prototype);
+        this.Type = opts.Type;
+        this.Message = opts.Message;
+    }
+}
+export const ThrottleReason = {
+    CallerRateLimitExceeded: "CallerRateLimitExceeded",
+    ConcurrentInvocationLimitExceeded: "ConcurrentInvocationLimitExceeded",
+    ConcurrentSnapshotCreateLimitExceeded: "ConcurrentSnapshotCreateLimitExceeded",
+    FunctionInvocationRateLimitExceeded: "FunctionInvocationRateLimitExceeded",
+    ReservedFunctionConcurrentInvocationLimitExceeded: "ReservedFunctionConcurrentInvocationLimitExceeded",
+    ReservedFunctionInvocationRateLimitExceeded: "ReservedFunctionInvocationRateLimitExceeded",
+};
+export class TooManyRequestsException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "TooManyRequestsException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "TooManyRequestsException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, TooManyRequestsException.prototype);
+        this.retryAfterSeconds = opts.retryAfterSeconds;
+        this.Type = opts.Type;
+        this.Reason = opts.Reason;
+    }
+}
+export const FunctionUrlAuthType = {
+    AWS_IAM: "AWS_IAM",
+    NONE: "NONE",
+};
+export const ApplicationLogLevel = {
+    Debug: "DEBUG",
+    Error: "ERROR",
+    Fatal: "FATAL",
+    Info: "INFO",
+    Trace: "TRACE",
+    Warn: "WARN",
+};
+export const Architecture = {
+    arm64: "arm64",
+    x86_64: "x86_64",
+};
+export const CodeSigningPolicy = {
+    Enforce: "Enforce",
+    Warn: "Warn",
+};
+export const FullDocument = {
+    Default: "Default",
+    UpdateLookup: "UpdateLookup",
+};
+export const FunctionResponseType = {
+    ReportBatchItemFailures: "ReportBatchItemFailures",
+};
+export const EndPointType = {
+    KAFKA_BOOTSTRAP_SERVERS: "KAFKA_BOOTSTRAP_SERVERS",
+};
+export const SourceAccessType = {
+    BASIC_AUTH: "BASIC_AUTH",
+    CLIENT_CERTIFICATE_TLS_AUTH: "CLIENT_CERTIFICATE_TLS_AUTH",
+    SASL_SCRAM_256_AUTH: "SASL_SCRAM_256_AUTH",
+    SASL_SCRAM_512_AUTH: "SASL_SCRAM_512_AUTH",
+    SERVER_ROOT_CA_CERTIFICATE: "SERVER_ROOT_CA_CERTIFICATE",
+    VIRTUAL_HOST: "VIRTUAL_HOST",
+    VPC_SECURITY_GROUP: "VPC_SECURITY_GROUP",
+    VPC_SUBNET: "VPC_SUBNET",
+};
+export const EventSourcePosition = {
+    AT_TIMESTAMP: "AT_TIMESTAMP",
+    LATEST: "LATEST",
+    TRIM_HORIZON: "TRIM_HORIZON",
+};
+export class CodeSigningConfigNotFoundException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "CodeSigningConfigNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "CodeSigningConfigNotFoundException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, CodeSigningConfigNotFoundException.prototype);
+        this.Type = opts.Type;
+        this.Message = opts.Message;
+    }
+}
+export class CodeStorageExceededException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "CodeStorageExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "CodeStorageExceededException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, CodeStorageExceededException.prototype);
+        this.Type = opts.Type;
+    }
+}
+export class CodeVerificationFailedException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "CodeVerificationFailedException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "CodeVerificationFailedException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, CodeVerificationFailedException.prototype);
+        this.Type = opts.Type;
+        this.Message = opts.Message;
+    }
+}
+export const LogFormat = {
+    Json: "JSON",
+    Text: "Text",
+};
+export const SystemLogLevel = {
+    Debug: "DEBUG",
+    Info: "INFO",
+    Warn: "WARN",
+};
+export const PackageType = {
+    Image: "Image",
+    Zip: "Zip",
+};
+export const Runtime = {
+    dotnet6: "dotnet6",
+    dotnetcore10: "dotnetcore1.0",
+    dotnetcore20: "dotnetcore2.0",
+    dotnetcore21: "dotnetcore2.1",
+    dotnetcore31: "dotnetcore3.1",
+    go1x: "go1.x",
+    java11: "java11",
+    java17: "java17",
+    java21: "java21",
+    java8: "java8",
+    java8al2: "java8.al2",
+    nodejs: "nodejs",
+    nodejs10x: "nodejs10.x",
+    nodejs12x: "nodejs12.x",
+    nodejs14x: "nodejs14.x",
+    nodejs16x: "nodejs16.x",
+    nodejs18x: "nodejs18.x",
+    nodejs20x: "nodejs20.x",
+    nodejs43: "nodejs4.3",
+    nodejs43edge: "nodejs4.3-edge",
+    nodejs610: "nodejs6.10",
+    nodejs810: "nodejs8.10",
+    provided: "provided",
+    providedal2: "provided.al2",
+    providedal2023: "provided.al2023",
+    python27: "python2.7",
+    python310: "python3.10",
+    python311: "python3.11",
+    python312: "python3.12",
+    python36: "python3.6",
+    python37: "python3.7",
+    python38: "python3.8",
+    python39: "python3.9",
+    ruby25: "ruby2.5",
+    ruby27: "ruby2.7",
+    ruby32: "ruby3.2",
+};
+export const SnapStartApplyOn = {
+    None: "None",
+    PublishedVersions: "PublishedVersions",
+};
+export const TracingMode = {
+    Active: "Active",
+    PassThrough: "PassThrough",
+};
+export const LastUpdateStatus = {
+    Failed: "Failed",
+    InProgress: "InProgress",
+    Successful: "Successful",
+};
+export const LastUpdateStatusReasonCode = {
+    DisabledKMSKey: "DisabledKMSKey",
+    EFSIOError: "EFSIOError",
+    EFSMountConnectivityError: "EFSMountConnectivityError",
+    EFSMountFailure: "EFSMountFailure",
+    EFSMountTimeout: "EFSMountTimeout",
+    EniLimitExceeded: "EniLimitExceeded",
+    FunctionError: "FunctionError",
+    ImageAccessDenied: "ImageAccessDenied",
+    ImageDeleted: "ImageDeleted",
+    InsufficientRolePermissions: "InsufficientRolePermissions",
+    InternalError: "InternalError",
+    InvalidConfiguration: "InvalidConfiguration",
+    InvalidImage: "InvalidImage",
+    InvalidRuntime: "InvalidRuntime",
+    InvalidSecurityGroup: "InvalidSecurityGroup",
+    InvalidStateKMSKey: "InvalidStateKMSKey",
+    InvalidSubnet: "InvalidSubnet",
+    InvalidZipFileException: "InvalidZipFileException",
+    KMSKeyAccessDenied: "KMSKeyAccessDenied",
+    KMSKeyNotFound: "KMSKeyNotFound",
+    SubnetOutOfIPAddresses: "SubnetOutOfIPAddresses",
+};
+export const SnapStartOptimizationStatus = {
+    Off: "Off",
+    On: "On",
+};
+export const State = {
+    Active: "Active",
+    Failed: "Failed",
+    Inactive: "Inactive",
+    Pending: "Pending",
+};
+export const StateReasonCode = {
+    Creating: "Creating",
+    DisabledKMSKey: "DisabledKMSKey",
+    EFSIOError: "EFSIOError",
+    EFSMountConnectivityError: "EFSMountConnectivityError",
+    EFSMountFailure: "EFSMountFailure",
+    EFSMountTimeout: "EFSMountTimeout",
+    EniLimitExceeded: "EniLimitExceeded",
+    FunctionError: "FunctionError",
+    Idle: "Idle",
+    ImageAccessDenied: "ImageAccessDenied",
+    ImageDeleted: "ImageDeleted",
+    InsufficientRolePermissions: "InsufficientRolePermissions",
+    InternalError: "InternalError",
+    InvalidConfiguration: "InvalidConfiguration",
+    InvalidImage: "InvalidImage",
+    InvalidRuntime: "InvalidRuntime",
+    InvalidSecurityGroup: "InvalidSecurityGroup",
+    InvalidStateKMSKey: "InvalidStateKMSKey",
+    InvalidSubnet: "InvalidSubnet",
+    InvalidZipFileException: "InvalidZipFileException",
+    KMSKeyAccessDenied: "KMSKeyAccessDenied",
+    KMSKeyNotFound: "KMSKeyNotFound",
+    Restoring: "Restoring",
+    SubnetOutOfIPAddresses: "SubnetOutOfIPAddresses",
+};
+export class InvalidCodeSignatureException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "InvalidCodeSignatureException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "InvalidCodeSignatureException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, InvalidCodeSignatureException.prototype);
+        this.Type = opts.Type;
+        this.Message = opts.Message;
+    }
+}
+export const InvokeMode = {
+    BUFFERED: "BUFFERED",
+    RESPONSE_STREAM: "RESPONSE_STREAM",
+};
+export class ResourceInUseException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ResourceInUseException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ResourceInUseException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ResourceInUseException.prototype);
+        this.Type = opts.Type;
+        this.Message = opts.Message;
+    }
+}
+export const ProvisionedConcurrencyStatusEnum = {
+    FAILED: "FAILED",
+    IN_PROGRESS: "IN_PROGRESS",
+    READY: "READY",
+};
+export class ProvisionedConcurrencyConfigNotFoundException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ProvisionedConcurrencyConfigNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ProvisionedConcurrencyConfigNotFoundException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ProvisionedConcurrencyConfigNotFoundException.prototype);
+        this.Type = opts.Type;
+    }
+}
+export const UpdateRuntimeOn = {
+    Auto: "Auto",
+    FunctionUpdate: "FunctionUpdate",
+    Manual: "Manual",
+};
+export class EC2AccessDeniedException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "EC2AccessDeniedException",
+            $fault: "server",
+            ...opts,
+        });
+        this.name = "EC2AccessDeniedException";
+        this.$fault = "server";
+        Object.setPrototypeOf(this, EC2AccessDeniedException.prototype);
+        this.Type = opts.Type;
+        this.Message = opts.Message;
+    }
+}
+export class EC2ThrottledException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "EC2ThrottledException",
+            $fault: "server",
+            ...opts,
+        });
+        this.name = "EC2ThrottledException";
+        this.$fault = "server";
+        Object.setPrototypeOf(this, EC2ThrottledException.prototype);
+        this.Type = opts.Type;
+        this.Message = opts.Message;
+    }
+}
+export class EC2UnexpectedException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "EC2UnexpectedException",
+            $fault: "server",
+            ...opts,
+        });
+        this.name = "EC2UnexpectedException";
+        this.$fault = "server";
+        Object.setPrototypeOf(this, EC2UnexpectedException.prototype);
+        this.Type = opts.Type;
+        this.Message = opts.Message;
+        this.EC2ErrorCode = opts.EC2ErrorCode;
+    }
+}
+export class EFSIOException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "EFSIOException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "EFSIOException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, EFSIOException.prototype);
+        this.Type = opts.Type;
+        this.Message = opts.Message;
+    }
+}
+export class EFSMountConnectivityException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "EFSMountConnectivityException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "EFSMountConnectivityException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, EFSMountConnectivityException.prototype);
+        this.Type = opts.Type;
+        this.Message = opts.Message;
+    }
+}
+export class EFSMountFailureException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "EFSMountFailureException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "EFSMountFailureException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, EFSMountFailureException.prototype);
+        this.Type = opts.Type;
+        this.Message = opts.Message;
+    }
+}
+export class EFSMountTimeoutException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "EFSMountTimeoutException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "EFSMountTimeoutException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, EFSMountTimeoutException.prototype);
+        this.Type = opts.Type;
+        this.Message = opts.Message;
+    }
+}
+export class ENILimitReachedException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ENILimitReachedException",
+            $fault: "server",
+            ...opts,
+        });
+        this.name = "ENILimitReachedException";
+        this.$fault = "server";
+        Object.setPrototypeOf(this, ENILimitReachedException.prototype);
+        this.Type = opts.Type;
+        this.Message = opts.Message;
+    }
+}
+export class InvalidRequestContentException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "InvalidRequestContentException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "InvalidRequestContentException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, InvalidRequestContentException.prototype);
+        this.Type = opts.Type;
+    }
+}
+export class InvalidRuntimeException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "InvalidRuntimeException",
+            $fault: "server",
+            ...opts,
+        });
+        this.name = "InvalidRuntimeException";
+        this.$fault = "server";
+        Object.setPrototypeOf(this, InvalidRuntimeException.prototype);
+        this.Type = opts.Type;
+        this.Message = opts.Message;
+    }
+}
+export class InvalidSecurityGroupIDException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "InvalidSecurityGroupIDException",
+            $fault: "server",
+            ...opts,
+        });
+        this.name = "InvalidSecurityGroupIDException";
+        this.$fault = "server";
+        Object.setPrototypeOf(this, InvalidSecurityGroupIDException.prototype);
+        this.Type = opts.Type;
+        this.Message = opts.Message;
+    }
+}
+export class InvalidSubnetIDException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "InvalidSubnetIDException",
+            $fault: "server",
+            ...opts,
+        });
+        this.name = "InvalidSubnetIDException";
+        this.$fault = "server";
+        Object.setPrototypeOf(this, InvalidSubnetIDException.prototype);
+        this.Type = opts.Type;
+        this.Message = opts.Message;
+    }
+}
+export class InvalidZipFileException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "InvalidZipFileException",
+            $fault: "server",
+            ...opts,
+        });
+        this.name = "InvalidZipFileException";
+        this.$fault = "server";
+        Object.setPrototypeOf(this, InvalidZipFileException.prototype);
+        this.Type = opts.Type;
+        this.Message = opts.Message;
+    }
+}
+export const InvocationType = {
+    DryRun: "DryRun",
+    Event: "Event",
+    RequestResponse: "RequestResponse",
+};
+export const LogType = {
+    None: "None",
+    Tail: "Tail",
+};
+export class KMSAccessDeniedException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "KMSAccessDeniedException",
+            $fault: "server",
+            ...opts,
+        });
+        this.name = "KMSAccessDeniedException";
+        this.$fault = "server";
+        Object.setPrototypeOf(this, KMSAccessDeniedException.prototype);
+        this.Type = opts.Type;
+        this.Message = opts.Message;
+    }
+}
+export class KMSDisabledException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "KMSDisabledException",
+            $fault: "server",
+            ...opts,
+        });
+        this.name = "KMSDisabledException";
+        this.$fault = "server";
+        Object.setPrototypeOf(this, KMSDisabledException.prototype);
+        this.Type = opts.Type;
+        this.Message = opts.Message;
+    }
+}
+export class KMSInvalidStateException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "KMSInvalidStateException",
+            $fault: "server",
+            ...opts,
+        });
+        this.name = "KMSInvalidStateException";
+        this.$fault = "server";
+        Object.setPrototypeOf(this, KMSInvalidStateException.prototype);
+        this.Type = opts.Type;
+        this.Message = opts.Message;
+    }
+}
+export class KMSNotFoundException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "KMSNotFoundException",
+            $fault: "server",
+            ...opts,
+        });
+        this.name = "KMSNotFoundException";
+        this.$fault = "server";
+        Object.setPrototypeOf(this, KMSNotFoundException.prototype);
+        this.Type = opts.Type;
+        this.Message = opts.Message;
+    }
+}
+export class RecursiveInvocationException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "RecursiveInvocationException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "RecursiveInvocationException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, RecursiveInvocationException.prototype);
+        this.Type = opts.Type;
+        this.Message = opts.Message;
+    }
+}
+export class RequestTooLargeException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "RequestTooLargeException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "RequestTooLargeException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, RequestTooLargeException.prototype);
+        this.Type = opts.Type;
+    }
+}
+export class ResourceNotReadyException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ResourceNotReadyException",
+            $fault: "server",
+            ...opts,
+        });
+        this.name = "ResourceNotReadyException";
+        this.$fault = "server";
+        Object.setPrototypeOf(this, ResourceNotReadyException.prototype);
+        this.Type = opts.Type;
+    }
+}
+export class SnapStartException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "SnapStartException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "SnapStartException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, SnapStartException.prototype);
+        this.Type = opts.Type;
+        this.Message = opts.Message;
+    }
+}
+export class SnapStartNotReadyException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "SnapStartNotReadyException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "SnapStartNotReadyException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, SnapStartNotReadyException.prototype);
+        this.Type = opts.Type;
+        this.Message = opts.Message;
+    }
+}
+export class SnapStartTimeoutException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "SnapStartTimeoutException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "SnapStartTimeoutException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, SnapStartTimeoutException.prototype);
+        this.Type = opts.Type;
+        this.Message = opts.Message;
+    }
+}
+export class SubnetIPAddressLimitReachedException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "SubnetIPAddressLimitReachedException",
+            $fault: "server",
+            ...opts,
+        });
+        this.name = "SubnetIPAddressLimitReachedException";
+        this.$fault = "server";
+        Object.setPrototypeOf(this, SubnetIPAddressLimitReachedException.prototype);
+        this.Type = opts.Type;
+        this.Message = opts.Message;
+    }
+}
+export class UnsupportedMediaTypeException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "UnsupportedMediaTypeException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "UnsupportedMediaTypeException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, UnsupportedMediaTypeException.prototype);
+        this.Type = opts.Type;
+    }
+}
+export const ResponseStreamingInvocationType = {
+    DryRun: "DryRun",
+    RequestResponse: "RequestResponse",
+};
+export var InvokeWithResponseStreamResponseEvent;
+(function (InvokeWithResponseStreamResponseEvent) {
+    InvokeWithResponseStreamResponseEvent.visit = (value, visitor) => {
+        if (value.PayloadChunk !== undefined)
+            return visitor.PayloadChunk(value.PayloadChunk);
+        if (value.InvokeComplete !== undefined)
+            return visitor.InvokeComplete(value.InvokeComplete);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(InvokeWithResponseStreamResponseEvent || (InvokeWithResponseStreamResponseEvent = {}));
+export const FunctionVersion = {
+    ALL: "ALL",
+};
+export const FunctionCodeFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.ZipFile && { ZipFile: SENSITIVE_STRING }),
+});
+export const EnvironmentFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Variables && { Variables: SENSITIVE_STRING }),
+});
+export const CreateFunctionRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Code && { Code: FunctionCodeFilterSensitiveLog(obj.Code) }),
+    ...(obj.Environment && { Environment: EnvironmentFilterSensitiveLog(obj.Environment) }),
+});
+export const EnvironmentErrorFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Message && { Message: SENSITIVE_STRING }),
+});
+export const EnvironmentResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Variables && { Variables: SENSITIVE_STRING }),
+    ...(obj.Error && { Error: EnvironmentErrorFilterSensitiveLog(obj.Error) }),
+});
+export const ImageConfigErrorFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Message && { Message: SENSITIVE_STRING }),
+});
+export const ImageConfigResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Error && { Error: ImageConfigErrorFilterSensitiveLog(obj.Error) }),
+});
+export const RuntimeVersionErrorFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Message && { Message: SENSITIVE_STRING }),
+});
+export const RuntimeVersionConfigFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Error && { Error: RuntimeVersionErrorFilterSensitiveLog(obj.Error) }),
+});
+export const FunctionConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Environment && { Environment: EnvironmentResponseFilterSensitiveLog(obj.Environment) }),
+    ...(obj.ImageConfigResponse && {
+        ImageConfigResponse: ImageConfigResponseFilterSensitiveLog(obj.ImageConfigResponse),
+    }),
+    ...(obj.RuntimeVersionConfig && {
+        RuntimeVersionConfig: RuntimeVersionConfigFilterSensitiveLog(obj.RuntimeVersionConfig),
+    }),
+});
+export const GetFunctionResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Configuration && { Configuration: FunctionConfigurationFilterSensitiveLog(obj.Configuration) }),
+});
+export const InvocationRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Payload && { Payload: SENSITIVE_STRING }),
+});
+export const InvocationResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Payload && { Payload: SENSITIVE_STRING }),
+});
+export const InvokeAsyncRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const InvokeWithResponseStreamRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Payload && { Payload: SENSITIVE_STRING }),
+});
+export const InvokeResponseStreamUpdateFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Payload && { Payload: SENSITIVE_STRING }),
+});
+export const InvokeWithResponseStreamResponseEventFilterSensitiveLog = (obj) => {
+    if (obj.PayloadChunk !== undefined)
+        return { PayloadChunk: InvokeResponseStreamUpdateFilterSensitiveLog(obj.PayloadChunk) };
+    if (obj.InvokeComplete !== undefined)
+        return { InvokeComplete: obj.InvokeComplete };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const InvokeWithResponseStreamResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.EventStream && { EventStream: "STREAMING_CONTENT" }),
+});
+export const ListFunctionsResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Functions && { Functions: obj.Functions.map((item) => FunctionConfigurationFilterSensitiveLog(item)) }),
+});
+export const ListVersionsByFunctionResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Versions && { Versions: obj.Versions.map((item) => FunctionConfigurationFilterSensitiveLog(item)) }),
+});
+export const LayerVersionContentInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.ZipFile && { ZipFile: SENSITIVE_STRING }),
+});
+export const PublishLayerVersionRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Content && { Content: LayerVersionContentInputFilterSensitiveLog(obj.Content) }),
+});
+export const UpdateFunctionCodeRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.ZipFile && { ZipFile: SENSITIVE_STRING }),
+});
+export const UpdateFunctionConfigurationRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Environment && { Environment: EnvironmentFilterSensitiveLog(obj.Environment) }),
+});

node_modules/@aws-sdk/client-lambda/dist-es/pagination/Interfaces.js

@@ -0,0 +1 @@
+export {};

node_modules/@aws-sdk/client-lambda/dist-es/pagination/ListAliasesPaginator.js

@@ -0,0 +1,25 @@
+import { ListAliasesCommand } from "../commands/ListAliasesCommand";
+import { LambdaClient } from "../LambdaClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListAliasesCommand(input), ...args);
+};
+export async function* paginateListAliases(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.Marker = token;
+        input["MaxItems"] = config.pageSize;
+        if (config.client instanceof LambdaClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected Lambda | LambdaClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextMarker;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

node_modules/@aws-sdk/client-lambda/dist-es/pagination/ListCodeSigningConfigsPaginator.js

@@ -0,0 +1,25 @@
+import { ListCodeSigningConfigsCommand, } from "../commands/ListCodeSigningConfigsCommand";
+import { LambdaClient } from "../LambdaClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListCodeSigningConfigsCommand(input), ...args);
+};
+export async function* paginateListCodeSigningConfigs(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.Marker = token;
+        input["MaxItems"] = config.pageSize;
+        if (config.client instanceof LambdaClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected Lambda | LambdaClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextMarker;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

node_modules/@aws-sdk/client-lambda/dist-es/pagination/ListEventSourceMappingsPaginator.js

@@ -0,0 +1,25 @@
+import { ListEventSourceMappingsCommand, } from "../commands/ListEventSourceMappingsCommand";
+import { LambdaClient } from "../LambdaClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListEventSourceMappingsCommand(input), ...args);
+};
+export async function* paginateListEventSourceMappings(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.Marker = token;
+        input["MaxItems"] = config.pageSize;
+        if (config.client instanceof LambdaClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected Lambda | LambdaClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextMarker;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

node_modules/@aws-sdk/client-lambda/dist-es/pagination/ListFunctionEventInvokeConfigsPaginator.js

@@ -0,0 +1,25 @@
+import { ListFunctionEventInvokeConfigsCommand, } from "../commands/ListFunctionEventInvokeConfigsCommand";
+import { LambdaClient } from "../LambdaClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListFunctionEventInvokeConfigsCommand(input), ...args);
+};
+export async function* paginateListFunctionEventInvokeConfigs(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.Marker = token;
+        input["MaxItems"] = config.pageSize;
+        if (config.client instanceof LambdaClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected Lambda | LambdaClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextMarker;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

node_modules/@aws-sdk/client-lambda/dist-es/pagination/ListFunctionUrlConfigsPaginator.js

@@ -0,0 +1,25 @@
+import { ListFunctionUrlConfigsCommand, } from "../commands/ListFunctionUrlConfigsCommand";
+import { LambdaClient } from "../LambdaClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListFunctionUrlConfigsCommand(input), ...args);
+};
+export async function* paginateListFunctionUrlConfigs(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.Marker = token;
+        input["MaxItems"] = config.pageSize;
+        if (config.client instanceof LambdaClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected Lambda | LambdaClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextMarker;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

node_modules/@aws-sdk/client-lambda/dist-es/pagination/ListFunctionsByCodeSigningConfigPaginator.js

@@ -0,0 +1,25 @@
+import { ListFunctionsByCodeSigningConfigCommand, } from "../commands/ListFunctionsByCodeSigningConfigCommand";
+import { LambdaClient } from "../LambdaClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListFunctionsByCodeSigningConfigCommand(input), ...args);
+};
+export async function* paginateListFunctionsByCodeSigningConfig(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.Marker = token;
+        input["MaxItems"] = config.pageSize;
+        if (config.client instanceof LambdaClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected Lambda | LambdaClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextMarker;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

node_modules/@aws-sdk/client-lambda/dist-es/pagination/ListFunctionsPaginator.js

@@ -0,0 +1,25 @@
+import { ListFunctionsCommand, } from "../commands/ListFunctionsCommand";
+import { LambdaClient } from "../LambdaClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListFunctionsCommand(input), ...args);
+};
+export async function* paginateListFunctions(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.Marker = token;
+        input["MaxItems"] = config.pageSize;
+        if (config.client instanceof LambdaClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected Lambda | LambdaClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextMarker;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

node_modules/@aws-sdk/client-lambda/dist-es/pagination/ListLayerVersionsPaginator.js

@@ -0,0 +1,25 @@
+import { ListLayerVersionsCommand, } from "../commands/ListLayerVersionsCommand";
+import { LambdaClient } from "../LambdaClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListLayerVersionsCommand(input), ...args);
+};
+export async function* paginateListLayerVersions(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.Marker = token;
+        input["MaxItems"] = config.pageSize;
+        if (config.client instanceof LambdaClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected Lambda | LambdaClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextMarker;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

node_modules/@aws-sdk/client-lambda/dist-es/pagination/ListLayersPaginator.js

@@ -0,0 +1,25 @@
+import { ListLayersCommand } from "../commands/ListLayersCommand";
+import { LambdaClient } from "../LambdaClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListLayersCommand(input), ...args);
+};
+export async function* paginateListLayers(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.Marker = token;
+        input["MaxItems"] = config.pageSize;
+        if (config.client instanceof LambdaClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected Lambda | LambdaClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextMarker;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

node_modules/@aws-sdk/client-lambda/dist-es/pagination/ListProvisionedConcurrencyConfigsPaginator.js

@@ -0,0 +1,25 @@
+import { ListProvisionedConcurrencyConfigsCommand, } from "../commands/ListProvisionedConcurrencyConfigsCommand";
+import { LambdaClient } from "../LambdaClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListProvisionedConcurrencyConfigsCommand(input), ...args);
+};
+export async function* paginateListProvisionedConcurrencyConfigs(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.Marker = token;
+        input["MaxItems"] = config.pageSize;
+        if (config.client instanceof LambdaClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected Lambda | LambdaClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextMarker;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

node_modules/@aws-sdk/client-lambda/dist-es/pagination/ListVersionsByFunctionPaginator.js

@@ -0,0 +1,25 @@
+import { ListVersionsByFunctionCommand, } from "../commands/ListVersionsByFunctionCommand";
+import { LambdaClient } from "../LambdaClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListVersionsByFunctionCommand(input), ...args);
+};
+export async function* paginateListVersionsByFunction(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.Marker = token;
+        input["MaxItems"] = config.pageSize;
+        if (config.client instanceof LambdaClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected Lambda | LambdaClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextMarker;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

node_modules/@aws-sdk/client-lambda/dist-es/pagination/index.js

@@ -0,0 +1,12 @@
+export * from "./Interfaces";
+export * from "./ListAliasesPaginator";
+export * from "./ListCodeSigningConfigsPaginator";
+export * from "./ListEventSourceMappingsPaginator";
+export * from "./ListFunctionEventInvokeConfigsPaginator";
+export * from "./ListFunctionUrlConfigsPaginator";
+export * from "./ListFunctionsByCodeSigningConfigPaginator";
+export * from "./ListFunctionsPaginator";
+export * from "./ListLayerVersionsPaginator";
+export * from "./ListLayersPaginator";
+export * from "./ListProvisionedConcurrencyConfigsPaginator";
+export * from "./ListVersionsByFunctionPaginator";

node_modules/@aws-sdk/client-lambda/dist-es/runtimeConfig.browser.js

@@ -0,0 +1,36 @@
+import packageInfo from "../package.json";
+import { Sha256 } from "@aws-crypto/sha256-browser";
+import { defaultUserAgent } from "@aws-sdk/util-user-agent-browser";
+import { DEFAULT_USE_DUALSTACK_ENDPOINT, DEFAULT_USE_FIPS_ENDPOINT } from "@smithy/config-resolver";
+import { eventStreamSerdeProvider } from "@smithy/eventstream-serde-browser";
+import { FetchHttpHandler as RequestHandler, streamCollector } from "@smithy/fetch-http-handler";
+import { invalidProvider } from "@smithy/invalid-dependency";
+import { calculateBodyLength } from "@smithy/util-body-length-browser";
+import { DEFAULT_MAX_ATTEMPTS, DEFAULT_RETRY_MODE } from "@smithy/util-retry";
+import { getRuntimeConfig as getSharedRuntimeConfig } from "./runtimeConfig.shared";
+import { loadConfigsForDefaultMode } from "@smithy/smithy-client";
+import { resolveDefaultsModeConfig } from "@smithy/util-defaults-mode-browser";
+export const getRuntimeConfig = (config) => {
+    const defaultsMode = resolveDefaultsModeConfig(config);
+    const defaultConfigProvider = () => defaultsMode().then(loadConfigsForDefaultMode);
+    const clientSharedValues = getSharedRuntimeConfig(config);
+    return {
+        ...clientSharedValues,
+        ...config,
+        runtime: "browser",
+        defaultsMode,
+        bodyLengthChecker: config?.bodyLengthChecker ?? calculateBodyLength,
+        credentialDefaultProvider: config?.credentialDefaultProvider ?? ((_) => () => Promise.reject(new Error("Credential is missing"))),
+        defaultUserAgentProvider: config?.defaultUserAgentProvider ??
+            defaultUserAgent({ serviceId: clientSharedValues.serviceId, clientVersion: packageInfo.version }),
+        eventStreamSerdeProvider: config?.eventStreamSerdeProvider ?? eventStreamSerdeProvider,
+        maxAttempts: config?.maxAttempts ?? DEFAULT_MAX_ATTEMPTS,
+        region: config?.region ?? invalidProvider("Region is missing"),
+        requestHandler: config?.requestHandler ?? new RequestHandler(defaultConfigProvider),
+        retryMode: config?.retryMode ?? (async () => (await defaultConfigProvider()).retryMode || DEFAULT_RETRY_MODE),
+        sha256: config?.sha256 ?? Sha256,
+        streamCollector: config?.streamCollector ?? streamCollector,
+        useDualstackEndpoint: config?.useDualstackEndpoint ?? (() => Promise.resolve(DEFAULT_USE_DUALSTACK_ENDPOINT)),
+        useFipsEndpoint: config?.useFipsEndpoint ?? (() => Promise.resolve(DEFAULT_USE_FIPS_ENDPOINT)),
+    };
+};

node_modules/@aws-sdk/client-lambda/dist-es/runtimeConfig.js

@@ -0,0 +1,47 @@
+import packageInfo from "../package.json";
+import { decorateDefaultCredentialProvider } from "@aws-sdk/client-sts";
+import { emitWarningIfUnsupportedVersion as awsCheckVersion } from "@aws-sdk/core";
+import { defaultProvider as credentialDefaultProvider } from "@aws-sdk/credential-provider-node";
+import { defaultUserAgent } from "@aws-sdk/util-user-agent-node";
+import { NODE_REGION_CONFIG_FILE_OPTIONS, NODE_REGION_CONFIG_OPTIONS, NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, } from "@smithy/config-resolver";
+import { eventStreamSerdeProvider } from "@smithy/eventstream-serde-node";
+import { Hash } from "@smithy/hash-node";
+import { NODE_MAX_ATTEMPT_CONFIG_OPTIONS, NODE_RETRY_MODE_CONFIG_OPTIONS } from "@smithy/middleware-retry";
+import { loadConfig as loadNodeConfig } from "@smithy/node-config-provider";
+import { NodeHttpHandler as RequestHandler, streamCollector } from "@smithy/node-http-handler";
+import { calculateBodyLength } from "@smithy/util-body-length-node";
+import { DEFAULT_RETRY_MODE } from "@smithy/util-retry";
+import { getRuntimeConfig as getSharedRuntimeConfig } from "./runtimeConfig.shared";
+import { loadConfigsForDefaultMode } from "@smithy/smithy-client";
+import { resolveDefaultsModeConfig } from "@smithy/util-defaults-mode-node";
+import { emitWarningIfUnsupportedVersion } from "@smithy/smithy-client";
+export const getRuntimeConfig = (config) => {
+    emitWarningIfUnsupportedVersion(process.version);
+    const defaultsMode = resolveDefaultsModeConfig(config);
+    const defaultConfigProvider = () => defaultsMode().then(loadConfigsForDefaultMode);
+    const clientSharedValues = getSharedRuntimeConfig(config);
+    awsCheckVersion(process.version);
+    return {
+        ...clientSharedValues,
+        ...config,
+        runtime: "node",
+        defaultsMode,
+        bodyLengthChecker: config?.bodyLengthChecker ?? calculateBodyLength,
+        credentialDefaultProvider: config?.credentialDefaultProvider ?? decorateDefaultCredentialProvider(credentialDefaultProvider),
+        defaultUserAgentProvider: config?.defaultUserAgentProvider ??
+            defaultUserAgent({ serviceId: clientSharedValues.serviceId, clientVersion: packageInfo.version }),
+        eventStreamSerdeProvider: config?.eventStreamSerdeProvider ?? eventStreamSerdeProvider,
+        maxAttempts: config?.maxAttempts ?? loadNodeConfig(NODE_MAX_ATTEMPT_CONFIG_OPTIONS),
+        region: config?.region ?? loadNodeConfig(NODE_REGION_CONFIG_OPTIONS, NODE_REGION_CONFIG_FILE_OPTIONS),
+        requestHandler: config?.requestHandler ?? new RequestHandler(defaultConfigProvider),
+        retryMode: config?.retryMode ??
+            loadNodeConfig({
+                ...NODE_RETRY_MODE_CONFIG_OPTIONS,
+                default: async () => (await defaultConfigProvider()).retryMode || DEFAULT_RETRY_MODE,
+            }),
+        sha256: config?.sha256 ?? Hash.bind(null, "sha256"),
+        streamCollector: config?.streamCollector ?? streamCollector,
+        useDualstackEndpoint: config?.useDualstackEndpoint ?? loadNodeConfig(NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS),
+        useFipsEndpoint: config?.useFipsEndpoint ?? loadNodeConfig(NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS),
+    };
+};

node_modules/@aws-sdk/client-lambda/dist-es/runtimeConfig.native.js

@@ -0,0 +1,11 @@
+import { Sha256 } from "@aws-crypto/sha256-js";
+import { getRuntimeConfig as getBrowserRuntimeConfig } from "./runtimeConfig.browser";
+export const getRuntimeConfig = (config) => {
+    const browserDefaults = getBrowserRuntimeConfig(config);
+    return {
+        ...browserDefaults,
+        ...config,
+        runtime: "react-native",
+        sha256: config?.sha256 ?? Sha256,
+    };
+};

node_modules/@aws-sdk/client-lambda/dist-es/runtimeConfig.shared.js

@@ -0,0 +1,20 @@
+import { NoOpLogger } from "@smithy/smithy-client";
+import { parseUrl } from "@smithy/url-parser";
+import { fromBase64, toBase64 } from "@smithy/util-base64";
+import { fromUtf8, toUtf8 } from "@smithy/util-utf8";
+import { defaultEndpointResolver } from "./endpoint/endpointResolver";
+export const getRuntimeConfig = (config) => {
+    return {
+        apiVersion: "2015-03-31",
+        base64Decoder: config?.base64Decoder ?? fromBase64,
+        base64Encoder: config?.base64Encoder ?? toBase64,
+        disableHostPrefix: config?.disableHostPrefix ?? false,
+        endpointProvider: config?.endpointProvider ?? defaultEndpointResolver,
+        extensions: config?.extensions ?? [],
+        logger: config?.logger ?? new NoOpLogger(),
+        serviceId: config?.serviceId ?? "Lambda",
+        urlParser: config?.urlParser ?? parseUrl,
+        utf8Decoder: config?.utf8Decoder ?? fromUtf8,
+        utf8Encoder: config?.utf8Encoder ?? toUtf8,
+    };
+};

node_modules/@aws-sdk/client-lambda/dist-es/runtimeExtensions.js

@@ -0,0 +1,18 @@
+import { getAwsRegionExtensionConfiguration, resolveAwsRegionExtensionConfiguration, } from "@aws-sdk/region-config-resolver";
+import { getHttpHandlerExtensionConfiguration, resolveHttpHandlerRuntimeConfig } from "@smithy/protocol-http";
+import { getDefaultExtensionConfiguration, resolveDefaultRuntimeConfig } from "@smithy/smithy-client";
+const asPartial = (t) => t;
+export const resolveRuntimeExtensions = (runtimeConfig, extensions) => {
+    const extensionConfiguration = {
+        ...asPartial(getAwsRegionExtensionConfiguration(runtimeConfig)),
+        ...asPartial(getDefaultExtensionConfiguration(runtimeConfig)),
+        ...asPartial(getHttpHandlerExtensionConfiguration(runtimeConfig)),
+    };
+    extensions.forEach((extension) => extension.configure(extensionConfiguration));
+    return {
+        ...runtimeConfig,
+        ...resolveAwsRegionExtensionConfiguration(extensionConfiguration),
+        ...resolveDefaultRuntimeConfig(extensionConfiguration),
+        ...resolveHttpHandlerRuntimeConfig(extensionConfiguration),
+    };
+};

node_modules/@aws-sdk/client-lambda/dist-es/waiters/index.js

@@ -0,0 +1,6 @@
+export * from "./waitForFunctionActive";
+export * from "./waitForFunctionActiveV2";
+export * from "./waitForFunctionExists";
+export * from "./waitForFunctionUpdated";
+export * from "./waitForFunctionUpdatedV2";
+export * from "./waitForPublishedVersionActive";

node_modules/@aws-sdk/client-lambda/dist-es/waiters/waitForFunctionActive.js

@@ -0,0 +1,49 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { GetFunctionConfigurationCommand, } from "../commands/GetFunctionConfigurationCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new GetFunctionConfigurationCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.State;
+            };
+            if (returnComparator() === "Active") {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.State;
+            };
+            if (returnComparator() === "Failed") {
+                return { state: WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.State;
+            };
+            if (returnComparator() === "Pending") {
+                return { state: WaiterState.RETRY, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForFunctionActive = async (params, input) => {
+    const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilFunctionActive = async (params, input) => {
+    const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

node_modules/@aws-sdk/client-lambda/dist-es/waiters/waitForFunctionActiveV2.js

@@ -0,0 +1,49 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { GetFunctionCommand } from "../commands/GetFunctionCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new GetFunctionCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.Configuration.State;
+            };
+            if (returnComparator() === "Active") {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.Configuration.State;
+            };
+            if (returnComparator() === "Failed") {
+                return { state: WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.Configuration.State;
+            };
+            if (returnComparator() === "Pending") {
+                return { state: WaiterState.RETRY, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForFunctionActiveV2 = async (params, input) => {
+    const serviceDefaults = { minDelay: 1, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilFunctionActiveV2 = async (params, input) => {
+    const serviceDefaults = { minDelay: 1, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

node_modules/@aws-sdk/client-lambda/dist-es/waiters/waitForFunctionExists.js

@@ -0,0 +1,26 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { GetFunctionCommand } from "../commands/GetFunctionCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new GetFunctionCommand(input));
+        reason = result;
+        return { state: WaiterState.SUCCESS, reason };
+    }
+    catch (exception) {
+        reason = exception;
+        if (exception.name && exception.name == "ResourceNotFoundException") {
+            return { state: WaiterState.RETRY, reason };
+        }
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForFunctionExists = async (params, input) => {
+    const serviceDefaults = { minDelay: 1, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilFunctionExists = async (params, input) => {
+    const serviceDefaults = { minDelay: 1, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};