@cdklabs/cdk-ssm-documents 0.0.64 → 0.0.66

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

@@ -1,19 +1,22 @@
-'use strict';
-
-var client$1 = require('@aws-sdk/core/client');
-var core = require('@smithy/core');
-var client = require('@smithy/core/client');
-var config = require('@smithy/core/config');
-var endpoints = require('@smithy/core/endpoints');
-var eventStreams = require('@smithy/core/event-streams');
-var protocols = require('@smithy/core/protocols');
-var retry = require('@smithy/core/retry');
-var schema = require('@smithy/core/schema');
-var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
-var runtimeConfig = require('./runtimeConfig');
-var schemas_0 = require('./schemas/schemas_0');
-var errors = require('./models/errors');
-var LambdaServiceException = require('./models/LambdaServiceException');
+var __exportStar = (m, e) => { Object.assign(e, m); };
+const { getAwsRegionExtensionConfiguration, resolveAwsRegionExtensionConfiguration, resolveUserAgentConfig, resolveHostHeaderConfig, getUserAgentPlugin, getHostHeaderPlugin, getLoggerPlugin, getRecursionDetectionPlugin } = require("@aws-sdk/core/client");
+const { getHttpAuthSchemeEndpointRuleSetPlugin, DefaultIdentityProviderConfig, getHttpSigningPlugin, createPaginator } = require("@smithy/core");
+const { getDefaultExtensionConfiguration, resolveDefaultRuntimeConfig, Client, Command, createWaiter, checkExceptions, WaiterState, createAggregatedClient } = require("@smithy/core/client");
+exports.$Command = Command;
+exports.__Client = Client;
+const { resolveRegionConfig } = require("@smithy/core/config");
+const { resolveEndpointConfig, getEndpointPlugin } = require("@smithy/core/endpoints");
+const { resolveEventStreamSerdeConfig } = require("@smithy/core/event-streams");
+const { getHttpHandlerExtensionConfiguration, resolveHttpHandlerRuntimeConfig, getContentLengthPlugin } = require("@smithy/core/protocols");
+const { resolveRetryConfig, getRetryPlugin } = require("@smithy/core/retry");
+const { getSchemaSerdePlugin } = require("@smithy/core/schema");
+const { resolveHttpAuthSchemeConfig, defaultLambdaHttpAuthSchemeParametersProvider } = require("./auth/httpAuthSchemeProvider");
+const { getRuntimeConfig } = require("./runtimeConfig");
+const { AddLayerVersionPermission$, AddPermission$, CheckpointDurableExecution$, CreateAlias$, CreateCapacityProvider$, CreateCodeSigningConfig$, CreateEventSourceMapping$, CreateFunction$, CreateFunctionUrlConfig$, DeleteAlias$, DeleteCapacityProvider$, DeleteCodeSigningConfig$, DeleteEventSourceMapping$, DeleteFunctionCodeSigningConfig$, DeleteFunction$, DeleteFunctionConcurrency$, DeleteFunctionEventInvokeConfig$, DeleteFunctionUrlConfig$, DeleteLayerVersion$, DeleteProvisionedConcurrencyConfig$, GetAccountSettings$, GetAlias$, GetCapacityProvider$, GetCodeSigningConfig$, GetDurableExecution$, GetDurableExecutionHistory$, GetDurableExecutionState$, GetEventSourceMapping$, GetFunctionCodeSigningConfig$, GetFunction$, GetFunctionConcurrency$, GetFunctionConfiguration$, GetFunctionEventInvokeConfig$, GetFunctionRecursionConfig$, GetFunctionScalingConfig$, GetFunctionUrlConfig$, GetLayerVersionByArn$, GetLayerVersion$, GetLayerVersionPolicy$, GetPolicy$, GetProvisionedConcurrencyConfig$, GetRuntimeManagementConfig$, InvokeAsync$, Invoke$, InvokeWithResponseStream$, ListAliases$, ListCapacityProviders$, ListCodeSigningConfigs$, ListDurableExecutionsByFunction$, ListEventSourceMappings$, ListFunctionEventInvokeConfigs$, ListFunctionsByCodeSigningConfig$, ListFunctions$, ListFunctionUrlConfigs$, ListFunctionVersionsByCapacityProvider$, ListLayers$, ListLayerVersions$, ListProvisionedConcurrencyConfigs$, ListTags$, ListVersionsByFunction$, PublishLayerVersion$, PublishVersion$, PutFunctionCodeSigningConfig$, PutFunctionConcurrency$, PutFunctionEventInvokeConfig$, PutFunctionRecursionConfig$, PutFunctionScalingConfig$, PutProvisionedConcurrencyConfig$, PutRuntimeManagementConfig$, RemoveLayerVersionPermission$, RemovePermission$, SendDurableExecutionCallbackFailure$, SendDurableExecutionCallbackHeartbeat$, SendDurableExecutionCallbackSuccess$, StopDurableExecution$, TagResource$, UntagResource$, UpdateAlias$, UpdateCapacityProvider$, UpdateCodeSigningConfig$, UpdateEventSourceMapping$, UpdateFunctionCode$, UpdateFunctionConfiguration$, UpdateFunctionEventInvokeConfig$, UpdateFunctionUrlConfig$ } = require("./schemas/schemas_0");
+__exportStar(require("./schemas/schemas_0"), exports);
+__exportStar(require("./models/errors"), exports);
+const { LambdaServiceException } = require("./models/LambdaServiceException");
+exports.LambdaServiceException = LambdaServiceException;
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -69,580 +72,580 @@ const resolveHttpAuthRuntimeConfig = (config) => {
 };
 
 const resolveRuntimeExtensions = (runtimeConfig, extensions) => {
-    const extensionConfiguration = Object.assign(client$1.getAwsRegionExtensionConfiguration(runtimeConfig), client.getDefaultExtensionConfiguration(runtimeConfig), protocols.getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
+    const extensionConfiguration = Object.assign(getAwsRegionExtensionConfiguration(runtimeConfig), getDefaultExtensionConfiguration(runtimeConfig), getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
     extensions.forEach((extension) => extension.configure(extensionConfiguration));
-    return Object.assign(runtimeConfig, client$1.resolveAwsRegionExtensionConfiguration(extensionConfiguration), client.resolveDefaultRuntimeConfig(extensionConfiguration), protocols.resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
+    return Object.assign(runtimeConfig, resolveAwsRegionExtensionConfiguration(extensionConfiguration), resolveDefaultRuntimeConfig(extensionConfiguration), resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
 };
 
-class LambdaClient extends client.Client {
+class LambdaClient extends Client {
     config;
     constructor(...[configuration]) {
-        const _config_0 = runtimeConfig.getRuntimeConfig(configuration || {});
+        const _config_0 = getRuntimeConfig(configuration || {});
         super(_config_0);
         this.initConfig = _config_0;
         const _config_1 = resolveClientEndpointParameters(_config_0);
-        const _config_2 = client$1.resolveUserAgentConfig(_config_1);
-        const _config_3 = retry.resolveRetryConfig(_config_2);
-        const _config_4 = config.resolveRegionConfig(_config_3);
-        const _config_5 = client$1.resolveHostHeaderConfig(_config_4);
-        const _config_6 = endpoints.resolveEndpointConfig(_config_5);
-        const _config_7 = eventStreams.resolveEventStreamSerdeConfig(_config_6);
-        const _config_8 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_7);
+        const _config_2 = resolveUserAgentConfig(_config_1);
+        const _config_3 = resolveRetryConfig(_config_2);
+        const _config_4 = resolveRegionConfig(_config_3);
+        const _config_5 = resolveHostHeaderConfig(_config_4);
+        const _config_6 = resolveEndpointConfig(_config_5);
+        const _config_7 = resolveEventStreamSerdeConfig(_config_6);
+        const _config_8 = resolveHttpAuthSchemeConfig(_config_7);
         const _config_9 = resolveRuntimeExtensions(_config_8, configuration?.extensions || []);
         this.config = _config_9;
-        this.middlewareStack.use(schema.getSchemaSerdePlugin(this.config));
-        this.middlewareStack.use(client$1.getUserAgentPlugin(this.config));
-        this.middlewareStack.use(retry.getRetryPlugin(this.config));
-        this.middlewareStack.use(protocols.getContentLengthPlugin(this.config));
-        this.middlewareStack.use(client$1.getHostHeaderPlugin(this.config));
-        this.middlewareStack.use(client$1.getLoggerPlugin(this.config));
-        this.middlewareStack.use(client$1.getRecursionDetectionPlugin(this.config));
-        this.middlewareStack.use(core.getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
-            httpAuthSchemeParametersProvider: httpAuthSchemeProvider.defaultLambdaHttpAuthSchemeParametersProvider,
-            identityProviderConfigProvider: async (config) => new core.DefaultIdentityProviderConfig({
+        this.middlewareStack.use(getSchemaSerdePlugin(this.config));
+        this.middlewareStack.use(getUserAgentPlugin(this.config));
+        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(getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
+            httpAuthSchemeParametersProvider: defaultLambdaHttpAuthSchemeParametersProvider,
+            identityProviderConfigProvider: async (config) => new DefaultIdentityProviderConfig({
                 "aws.auth#sigv4": config.credentials,
             }),
         }));
-        this.middlewareStack.use(core.getHttpSigningPlugin(this.config));
+        this.middlewareStack.use(getHttpSigningPlugin(this.config));
     }
     destroy() {
         super.destroy();
     }
 }
 
-class AddLayerVersionPermissionCommand extends client.Command
+class AddLayerVersionPermissionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "AddLayerVersionPermission", {})
     .n("LambdaClient", "AddLayerVersionPermissionCommand")
-    .sc(schemas_0.AddLayerVersionPermission$)
+    .sc(AddLayerVersionPermission$)
     .build() {
 }
 
-class AddPermissionCommand extends client.Command
+class AddPermissionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "AddPermission", {})
     .n("LambdaClient", "AddPermissionCommand")
-    .sc(schemas_0.AddPermission$)
+    .sc(AddPermission$)
     .build() {
 }
 
-class CheckpointDurableExecutionCommand extends client.Command
+class CheckpointDurableExecutionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "CheckpointDurableExecution", {})
     .n("LambdaClient", "CheckpointDurableExecutionCommand")
-    .sc(schemas_0.CheckpointDurableExecution$)
+    .sc(CheckpointDurableExecution$)
     .build() {
 }
 
-class CreateAliasCommand extends client.Command
+class CreateAliasCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "CreateAlias", {})
     .n("LambdaClient", "CreateAliasCommand")
-    .sc(schemas_0.CreateAlias$)
+    .sc(CreateAlias$)
     .build() {
 }
 
-class CreateCapacityProviderCommand extends client.Command
+class CreateCapacityProviderCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "CreateCapacityProvider", {})
     .n("LambdaClient", "CreateCapacityProviderCommand")
-    .sc(schemas_0.CreateCapacityProvider$)
+    .sc(CreateCapacityProvider$)
     .build() {
 }
 
-class CreateCodeSigningConfigCommand extends client.Command
+class CreateCodeSigningConfigCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "CreateCodeSigningConfig", {})
     .n("LambdaClient", "CreateCodeSigningConfigCommand")
-    .sc(schemas_0.CreateCodeSigningConfig$)
+    .sc(CreateCodeSigningConfig$)
     .build() {
 }
 
-class CreateEventSourceMappingCommand extends client.Command
+class CreateEventSourceMappingCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "CreateEventSourceMapping", {})
     .n("LambdaClient", "CreateEventSourceMappingCommand")
-    .sc(schemas_0.CreateEventSourceMapping$)
+    .sc(CreateEventSourceMapping$)
     .build() {
 }
 
-class CreateFunctionCommand extends client.Command
+class CreateFunctionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "CreateFunction", {})
     .n("LambdaClient", "CreateFunctionCommand")
-    .sc(schemas_0.CreateFunction$)
+    .sc(CreateFunction$)
     .build() {
 }
 
-class CreateFunctionUrlConfigCommand extends client.Command
+class CreateFunctionUrlConfigCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "CreateFunctionUrlConfig", {})
     .n("LambdaClient", "CreateFunctionUrlConfigCommand")
-    .sc(schemas_0.CreateFunctionUrlConfig$)
+    .sc(CreateFunctionUrlConfig$)
     .build() {
 }
 
-class DeleteAliasCommand extends client.Command
+class DeleteAliasCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "DeleteAlias", {})
     .n("LambdaClient", "DeleteAliasCommand")
-    .sc(schemas_0.DeleteAlias$)
+    .sc(DeleteAlias$)
     .build() {
 }
 
-class DeleteCapacityProviderCommand extends client.Command
+class DeleteCapacityProviderCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "DeleteCapacityProvider", {})
     .n("LambdaClient", "DeleteCapacityProviderCommand")
-    .sc(schemas_0.DeleteCapacityProvider$)
+    .sc(DeleteCapacityProvider$)
     .build() {
 }
 
-class DeleteCodeSigningConfigCommand extends client.Command
+class DeleteCodeSigningConfigCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "DeleteCodeSigningConfig", {})
     .n("LambdaClient", "DeleteCodeSigningConfigCommand")
-    .sc(schemas_0.DeleteCodeSigningConfig$)
+    .sc(DeleteCodeSigningConfig$)
     .build() {
 }
 
-class DeleteEventSourceMappingCommand extends client.Command
+class DeleteEventSourceMappingCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "DeleteEventSourceMapping", {})
     .n("LambdaClient", "DeleteEventSourceMappingCommand")
-    .sc(schemas_0.DeleteEventSourceMapping$)
+    .sc(DeleteEventSourceMapping$)
     .build() {
 }
 
-class DeleteFunctionCodeSigningConfigCommand extends client.Command
+class DeleteFunctionCodeSigningConfigCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "DeleteFunctionCodeSigningConfig", {})
     .n("LambdaClient", "DeleteFunctionCodeSigningConfigCommand")
-    .sc(schemas_0.DeleteFunctionCodeSigningConfig$)
+    .sc(DeleteFunctionCodeSigningConfig$)
     .build() {
 }
 
-class DeleteFunctionCommand extends client.Command
+class DeleteFunctionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "DeleteFunction", {})
     .n("LambdaClient", "DeleteFunctionCommand")
-    .sc(schemas_0.DeleteFunction$)
+    .sc(DeleteFunction$)
     .build() {
 }
 
-class DeleteFunctionConcurrencyCommand extends client.Command
+class DeleteFunctionConcurrencyCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "DeleteFunctionConcurrency", {})
     .n("LambdaClient", "DeleteFunctionConcurrencyCommand")
-    .sc(schemas_0.DeleteFunctionConcurrency$)
+    .sc(DeleteFunctionConcurrency$)
     .build() {
 }
 
-class DeleteFunctionEventInvokeConfigCommand extends client.Command
+class DeleteFunctionEventInvokeConfigCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "DeleteFunctionEventInvokeConfig", {})
     .n("LambdaClient", "DeleteFunctionEventInvokeConfigCommand")
-    .sc(schemas_0.DeleteFunctionEventInvokeConfig$)
+    .sc(DeleteFunctionEventInvokeConfig$)
     .build() {
 }
 
-class DeleteFunctionUrlConfigCommand extends client.Command
+class DeleteFunctionUrlConfigCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "DeleteFunctionUrlConfig", {})
     .n("LambdaClient", "DeleteFunctionUrlConfigCommand")
-    .sc(schemas_0.DeleteFunctionUrlConfig$)
+    .sc(DeleteFunctionUrlConfig$)
     .build() {
 }
 
-class DeleteLayerVersionCommand extends client.Command
+class DeleteLayerVersionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "DeleteLayerVersion", {})
     .n("LambdaClient", "DeleteLayerVersionCommand")
-    .sc(schemas_0.DeleteLayerVersion$)
+    .sc(DeleteLayerVersion$)
     .build() {
 }
 
-class DeleteProvisionedConcurrencyConfigCommand extends client.Command
+class DeleteProvisionedConcurrencyConfigCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "DeleteProvisionedConcurrencyConfig", {})
     .n("LambdaClient", "DeleteProvisionedConcurrencyConfigCommand")
-    .sc(schemas_0.DeleteProvisionedConcurrencyConfig$)
+    .sc(DeleteProvisionedConcurrencyConfig$)
     .build() {
 }
 
-class GetAccountSettingsCommand extends client.Command
+class GetAccountSettingsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "GetAccountSettings", {})
     .n("LambdaClient", "GetAccountSettingsCommand")
-    .sc(schemas_0.GetAccountSettings$)
+    .sc(GetAccountSettings$)
     .build() {
 }
 
-class GetAliasCommand extends client.Command
+class GetAliasCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "GetAlias", {})
     .n("LambdaClient", "GetAliasCommand")
-    .sc(schemas_0.GetAlias$)
+    .sc(GetAlias$)
     .build() {
 }
 
-class GetCapacityProviderCommand extends client.Command
+class GetCapacityProviderCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "GetCapacityProvider", {})
     .n("LambdaClient", "GetCapacityProviderCommand")
-    .sc(schemas_0.GetCapacityProvider$)
+    .sc(GetCapacityProvider$)
     .build() {
 }
 
-class GetCodeSigningConfigCommand extends client.Command
+class GetCodeSigningConfigCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "GetCodeSigningConfig", {})
     .n("LambdaClient", "GetCodeSigningConfigCommand")
-    .sc(schemas_0.GetCodeSigningConfig$)
+    .sc(GetCodeSigningConfig$)
     .build() {
 }
 
-class GetDurableExecutionCommand extends client.Command
+class GetDurableExecutionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "GetDurableExecution", {})
     .n("LambdaClient", "GetDurableExecutionCommand")
-    .sc(schemas_0.GetDurableExecution$)
+    .sc(GetDurableExecution$)
     .build() {
 }
 
-class GetDurableExecutionHistoryCommand extends client.Command
+class GetDurableExecutionHistoryCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "GetDurableExecutionHistory", {})
     .n("LambdaClient", "GetDurableExecutionHistoryCommand")
-    .sc(schemas_0.GetDurableExecutionHistory$)
+    .sc(GetDurableExecutionHistory$)
     .build() {
 }
 
-class GetDurableExecutionStateCommand extends client.Command
+class GetDurableExecutionStateCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "GetDurableExecutionState", {})
     .n("LambdaClient", "GetDurableExecutionStateCommand")
-    .sc(schemas_0.GetDurableExecutionState$)
+    .sc(GetDurableExecutionState$)
     .build() {
 }
 
-class GetEventSourceMappingCommand extends client.Command
+class GetEventSourceMappingCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "GetEventSourceMapping", {})
     .n("LambdaClient", "GetEventSourceMappingCommand")
-    .sc(schemas_0.GetEventSourceMapping$)
+    .sc(GetEventSourceMapping$)
     .build() {
 }
 
-class GetFunctionCodeSigningConfigCommand extends client.Command
+class GetFunctionCodeSigningConfigCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "GetFunctionCodeSigningConfig", {})
     .n("LambdaClient", "GetFunctionCodeSigningConfigCommand")
-    .sc(schemas_0.GetFunctionCodeSigningConfig$)
+    .sc(GetFunctionCodeSigningConfig$)
     .build() {
 }
 
-class GetFunctionCommand extends client.Command
+class GetFunctionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "GetFunction", {})
     .n("LambdaClient", "GetFunctionCommand")
-    .sc(schemas_0.GetFunction$)
+    .sc(GetFunction$)
     .build() {
 }
 
-class GetFunctionConcurrencyCommand extends client.Command
+class GetFunctionConcurrencyCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "GetFunctionConcurrency", {})
     .n("LambdaClient", "GetFunctionConcurrencyCommand")
-    .sc(schemas_0.GetFunctionConcurrency$)
+    .sc(GetFunctionConcurrency$)
     .build() {
 }
 
-class GetFunctionConfigurationCommand extends client.Command
+class GetFunctionConfigurationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "GetFunctionConfiguration", {})
     .n("LambdaClient", "GetFunctionConfigurationCommand")
-    .sc(schemas_0.GetFunctionConfiguration$)
+    .sc(GetFunctionConfiguration$)
     .build() {
 }
 
-class GetFunctionEventInvokeConfigCommand extends client.Command
+class GetFunctionEventInvokeConfigCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "GetFunctionEventInvokeConfig", {})
     .n("LambdaClient", "GetFunctionEventInvokeConfigCommand")
-    .sc(schemas_0.GetFunctionEventInvokeConfig$)
+    .sc(GetFunctionEventInvokeConfig$)
     .build() {
 }
 
-class GetFunctionRecursionConfigCommand extends client.Command
+class GetFunctionRecursionConfigCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "GetFunctionRecursionConfig", {})
     .n("LambdaClient", "GetFunctionRecursionConfigCommand")
-    .sc(schemas_0.GetFunctionRecursionConfig$)
+    .sc(GetFunctionRecursionConfig$)
     .build() {
 }
 
-class GetFunctionScalingConfigCommand extends client.Command
+class GetFunctionScalingConfigCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "GetFunctionScalingConfig", {})
     .n("LambdaClient", "GetFunctionScalingConfigCommand")
-    .sc(schemas_0.GetFunctionScalingConfig$)
+    .sc(GetFunctionScalingConfig$)
     .build() {
 }
 
-class GetFunctionUrlConfigCommand extends client.Command
+class GetFunctionUrlConfigCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "GetFunctionUrlConfig", {})
     .n("LambdaClient", "GetFunctionUrlConfigCommand")
-    .sc(schemas_0.GetFunctionUrlConfig$)
+    .sc(GetFunctionUrlConfig$)
     .build() {
 }
 
-class GetLayerVersionByArnCommand extends client.Command
+class GetLayerVersionByArnCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "GetLayerVersionByArn", {})
     .n("LambdaClient", "GetLayerVersionByArnCommand")
-    .sc(schemas_0.GetLayerVersionByArn$)
+    .sc(GetLayerVersionByArn$)
     .build() {
 }
 
-class GetLayerVersionCommand extends client.Command
+class GetLayerVersionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "GetLayerVersion", {})
     .n("LambdaClient", "GetLayerVersionCommand")
-    .sc(schemas_0.GetLayerVersion$)
+    .sc(GetLayerVersion$)
     .build() {
 }
 
-class GetLayerVersionPolicyCommand extends client.Command
+class GetLayerVersionPolicyCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "GetLayerVersionPolicy", {})
     .n("LambdaClient", "GetLayerVersionPolicyCommand")
-    .sc(schemas_0.GetLayerVersionPolicy$)
+    .sc(GetLayerVersionPolicy$)
     .build() {
 }
 
-class GetPolicyCommand extends client.Command
+class GetPolicyCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "GetPolicy", {})
     .n("LambdaClient", "GetPolicyCommand")
-    .sc(schemas_0.GetPolicy$)
+    .sc(GetPolicy$)
     .build() {
 }
 
-class GetProvisionedConcurrencyConfigCommand extends client.Command
+class GetProvisionedConcurrencyConfigCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "GetProvisionedConcurrencyConfig", {})
     .n("LambdaClient", "GetProvisionedConcurrencyConfigCommand")
-    .sc(schemas_0.GetProvisionedConcurrencyConfig$)
+    .sc(GetProvisionedConcurrencyConfig$)
     .build() {
 }
 
-class GetRuntimeManagementConfigCommand extends client.Command
+class GetRuntimeManagementConfigCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "GetRuntimeManagementConfig", {})
     .n("LambdaClient", "GetRuntimeManagementConfigCommand")
-    .sc(schemas_0.GetRuntimeManagementConfig$)
+    .sc(GetRuntimeManagementConfig$)
     .build() {
 }
 
-class InvokeAsyncCommand extends client.Command
+class InvokeAsyncCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "InvokeAsync", {})
     .n("LambdaClient", "InvokeAsyncCommand")
-    .sc(schemas_0.InvokeAsync$)
+    .sc(InvokeAsync$)
     .build() {
 }
 
-class InvokeCommand extends client.Command
+class InvokeCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "Invoke", {})
     .n("LambdaClient", "InvokeCommand")
-    .sc(schemas_0.Invoke$)
+    .sc(Invoke$)
     .build() {
 }
 
-class InvokeWithResponseStreamCommand extends client.Command
+class InvokeWithResponseStreamCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "InvokeWithResponseStream", {
     eventStream: {
@@ -650,533 +653,533 @@ class InvokeWithResponseStreamCommand extends client.Command
     },
 })
     .n("LambdaClient", "InvokeWithResponseStreamCommand")
-    .sc(schemas_0.InvokeWithResponseStream$)
+    .sc(InvokeWithResponseStream$)
     .build() {
 }
 
-class ListAliasesCommand extends client.Command
+class ListAliasesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "ListAliases", {})
     .n("LambdaClient", "ListAliasesCommand")
-    .sc(schemas_0.ListAliases$)
+    .sc(ListAliases$)
     .build() {
 }
 
-class ListCapacityProvidersCommand extends client.Command
+class ListCapacityProvidersCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "ListCapacityProviders", {})
     .n("LambdaClient", "ListCapacityProvidersCommand")
-    .sc(schemas_0.ListCapacityProviders$)
+    .sc(ListCapacityProviders$)
     .build() {
 }
 
-class ListCodeSigningConfigsCommand extends client.Command
+class ListCodeSigningConfigsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "ListCodeSigningConfigs", {})
     .n("LambdaClient", "ListCodeSigningConfigsCommand")
-    .sc(schemas_0.ListCodeSigningConfigs$)
+    .sc(ListCodeSigningConfigs$)
     .build() {
 }
 
-class ListDurableExecutionsByFunctionCommand extends client.Command
+class ListDurableExecutionsByFunctionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "ListDurableExecutionsByFunction", {})
     .n("LambdaClient", "ListDurableExecutionsByFunctionCommand")
-    .sc(schemas_0.ListDurableExecutionsByFunction$)
+    .sc(ListDurableExecutionsByFunction$)
     .build() {
 }
 
-class ListEventSourceMappingsCommand extends client.Command
+class ListEventSourceMappingsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "ListEventSourceMappings", {})
     .n("LambdaClient", "ListEventSourceMappingsCommand")
-    .sc(schemas_0.ListEventSourceMappings$)
+    .sc(ListEventSourceMappings$)
     .build() {
 }
 
-class ListFunctionEventInvokeConfigsCommand extends client.Command
+class ListFunctionEventInvokeConfigsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "ListFunctionEventInvokeConfigs", {})
     .n("LambdaClient", "ListFunctionEventInvokeConfigsCommand")
-    .sc(schemas_0.ListFunctionEventInvokeConfigs$)
+    .sc(ListFunctionEventInvokeConfigs$)
     .build() {
 }
 
-class ListFunctionsByCodeSigningConfigCommand extends client.Command
+class ListFunctionsByCodeSigningConfigCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "ListFunctionsByCodeSigningConfig", {})
     .n("LambdaClient", "ListFunctionsByCodeSigningConfigCommand")
-    .sc(schemas_0.ListFunctionsByCodeSigningConfig$)
+    .sc(ListFunctionsByCodeSigningConfig$)
     .build() {
 }
 
-class ListFunctionsCommand extends client.Command
+class ListFunctionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "ListFunctions", {})
     .n("LambdaClient", "ListFunctionsCommand")
-    .sc(schemas_0.ListFunctions$)
+    .sc(ListFunctions$)
     .build() {
 }
 
-class ListFunctionUrlConfigsCommand extends client.Command
+class ListFunctionUrlConfigsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "ListFunctionUrlConfigs", {})
     .n("LambdaClient", "ListFunctionUrlConfigsCommand")
-    .sc(schemas_0.ListFunctionUrlConfigs$)
+    .sc(ListFunctionUrlConfigs$)
     .build() {
 }
 
-class ListFunctionVersionsByCapacityProviderCommand extends client.Command
+class ListFunctionVersionsByCapacityProviderCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "ListFunctionVersionsByCapacityProvider", {})
     .n("LambdaClient", "ListFunctionVersionsByCapacityProviderCommand")
-    .sc(schemas_0.ListFunctionVersionsByCapacityProvider$)
+    .sc(ListFunctionVersionsByCapacityProvider$)
     .build() {
 }
 
-class ListLayersCommand extends client.Command
+class ListLayersCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "ListLayers", {})
     .n("LambdaClient", "ListLayersCommand")
-    .sc(schemas_0.ListLayers$)
+    .sc(ListLayers$)
     .build() {
 }
 
-class ListLayerVersionsCommand extends client.Command
+class ListLayerVersionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "ListLayerVersions", {})
     .n("LambdaClient", "ListLayerVersionsCommand")
-    .sc(schemas_0.ListLayerVersions$)
+    .sc(ListLayerVersions$)
     .build() {
 }
 
-class ListProvisionedConcurrencyConfigsCommand extends client.Command
+class ListProvisionedConcurrencyConfigsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "ListProvisionedConcurrencyConfigs", {})
     .n("LambdaClient", "ListProvisionedConcurrencyConfigsCommand")
-    .sc(schemas_0.ListProvisionedConcurrencyConfigs$)
+    .sc(ListProvisionedConcurrencyConfigs$)
     .build() {
 }
 
-class ListTagsCommand extends client.Command
+class ListTagsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "ListTags", {})
     .n("LambdaClient", "ListTagsCommand")
-    .sc(schemas_0.ListTags$)
+    .sc(ListTags$)
     .build() {
 }
 
-class ListVersionsByFunctionCommand extends client.Command
+class ListVersionsByFunctionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "ListVersionsByFunction", {})
     .n("LambdaClient", "ListVersionsByFunctionCommand")
-    .sc(schemas_0.ListVersionsByFunction$)
+    .sc(ListVersionsByFunction$)
     .build() {
 }
 
-class PublishLayerVersionCommand extends client.Command
+class PublishLayerVersionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "PublishLayerVersion", {})
     .n("LambdaClient", "PublishLayerVersionCommand")
-    .sc(schemas_0.PublishLayerVersion$)
+    .sc(PublishLayerVersion$)
     .build() {
 }
 
-class PublishVersionCommand extends client.Command
+class PublishVersionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "PublishVersion", {})
     .n("LambdaClient", "PublishVersionCommand")
-    .sc(schemas_0.PublishVersion$)
+    .sc(PublishVersion$)
     .build() {
 }
 
-class PutFunctionCodeSigningConfigCommand extends client.Command
+class PutFunctionCodeSigningConfigCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "PutFunctionCodeSigningConfig", {})
     .n("LambdaClient", "PutFunctionCodeSigningConfigCommand")
-    .sc(schemas_0.PutFunctionCodeSigningConfig$)
+    .sc(PutFunctionCodeSigningConfig$)
     .build() {
 }
 
-class PutFunctionConcurrencyCommand extends client.Command
+class PutFunctionConcurrencyCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "PutFunctionConcurrency", {})
     .n("LambdaClient", "PutFunctionConcurrencyCommand")
-    .sc(schemas_0.PutFunctionConcurrency$)
+    .sc(PutFunctionConcurrency$)
     .build() {
 }
 
-class PutFunctionEventInvokeConfigCommand extends client.Command
+class PutFunctionEventInvokeConfigCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "PutFunctionEventInvokeConfig", {})
     .n("LambdaClient", "PutFunctionEventInvokeConfigCommand")
-    .sc(schemas_0.PutFunctionEventInvokeConfig$)
+    .sc(PutFunctionEventInvokeConfig$)
     .build() {
 }
 
-class PutFunctionRecursionConfigCommand extends client.Command
+class PutFunctionRecursionConfigCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "PutFunctionRecursionConfig", {})
     .n("LambdaClient", "PutFunctionRecursionConfigCommand")
-    .sc(schemas_0.PutFunctionRecursionConfig$)
+    .sc(PutFunctionRecursionConfig$)
     .build() {
 }
 
-class PutFunctionScalingConfigCommand extends client.Command
+class PutFunctionScalingConfigCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "PutFunctionScalingConfig", {})
     .n("LambdaClient", "PutFunctionScalingConfigCommand")
-    .sc(schemas_0.PutFunctionScalingConfig$)
+    .sc(PutFunctionScalingConfig$)
     .build() {
 }
 
-class PutProvisionedConcurrencyConfigCommand extends client.Command
+class PutProvisionedConcurrencyConfigCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "PutProvisionedConcurrencyConfig", {})
     .n("LambdaClient", "PutProvisionedConcurrencyConfigCommand")
-    .sc(schemas_0.PutProvisionedConcurrencyConfig$)
+    .sc(PutProvisionedConcurrencyConfig$)
     .build() {
 }
 
-class PutRuntimeManagementConfigCommand extends client.Command
+class PutRuntimeManagementConfigCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "PutRuntimeManagementConfig", {})
     .n("LambdaClient", "PutRuntimeManagementConfigCommand")
-    .sc(schemas_0.PutRuntimeManagementConfig$)
+    .sc(PutRuntimeManagementConfig$)
     .build() {
 }
 
-class RemoveLayerVersionPermissionCommand extends client.Command
+class RemoveLayerVersionPermissionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "RemoveLayerVersionPermission", {})
     .n("LambdaClient", "RemoveLayerVersionPermissionCommand")
-    .sc(schemas_0.RemoveLayerVersionPermission$)
+    .sc(RemoveLayerVersionPermission$)
     .build() {
 }
 
-class RemovePermissionCommand extends client.Command
+class RemovePermissionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "RemovePermission", {})
     .n("LambdaClient", "RemovePermissionCommand")
-    .sc(schemas_0.RemovePermission$)
+    .sc(RemovePermission$)
     .build() {
 }
 
-class SendDurableExecutionCallbackFailureCommand extends client.Command
+class SendDurableExecutionCallbackFailureCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "SendDurableExecutionCallbackFailure", {})
     .n("LambdaClient", "SendDurableExecutionCallbackFailureCommand")
-    .sc(schemas_0.SendDurableExecutionCallbackFailure$)
+    .sc(SendDurableExecutionCallbackFailure$)
     .build() {
 }
 
-class SendDurableExecutionCallbackHeartbeatCommand extends client.Command
+class SendDurableExecutionCallbackHeartbeatCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "SendDurableExecutionCallbackHeartbeat", {})
     .n("LambdaClient", "SendDurableExecutionCallbackHeartbeatCommand")
-    .sc(schemas_0.SendDurableExecutionCallbackHeartbeat$)
+    .sc(SendDurableExecutionCallbackHeartbeat$)
     .build() {
 }
 
-class SendDurableExecutionCallbackSuccessCommand extends client.Command
+class SendDurableExecutionCallbackSuccessCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "SendDurableExecutionCallbackSuccess", {})
     .n("LambdaClient", "SendDurableExecutionCallbackSuccessCommand")
-    .sc(schemas_0.SendDurableExecutionCallbackSuccess$)
+    .sc(SendDurableExecutionCallbackSuccess$)
     .build() {
 }
 
-class StopDurableExecutionCommand extends client.Command
+class StopDurableExecutionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "StopDurableExecution", {})
     .n("LambdaClient", "StopDurableExecutionCommand")
-    .sc(schemas_0.StopDurableExecution$)
+    .sc(StopDurableExecution$)
     .build() {
 }
 
-class TagResourceCommand extends client.Command
+class TagResourceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "TagResource", {})
     .n("LambdaClient", "TagResourceCommand")
-    .sc(schemas_0.TagResource$)
+    .sc(TagResource$)
     .build() {
 }
 
-class UntagResourceCommand extends client.Command
+class UntagResourceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "UntagResource", {})
     .n("LambdaClient", "UntagResourceCommand")
-    .sc(schemas_0.UntagResource$)
+    .sc(UntagResource$)
     .build() {
 }
 
-class UpdateAliasCommand extends client.Command
+class UpdateAliasCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "UpdateAlias", {})
     .n("LambdaClient", "UpdateAliasCommand")
-    .sc(schemas_0.UpdateAlias$)
+    .sc(UpdateAlias$)
     .build() {
 }
 
-class UpdateCapacityProviderCommand extends client.Command
+class UpdateCapacityProviderCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "UpdateCapacityProvider", {})
     .n("LambdaClient", "UpdateCapacityProviderCommand")
-    .sc(schemas_0.UpdateCapacityProvider$)
+    .sc(UpdateCapacityProvider$)
     .build() {
 }
 
-class UpdateCodeSigningConfigCommand extends client.Command
+class UpdateCodeSigningConfigCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "UpdateCodeSigningConfig", {})
     .n("LambdaClient", "UpdateCodeSigningConfigCommand")
-    .sc(schemas_0.UpdateCodeSigningConfig$)
+    .sc(UpdateCodeSigningConfig$)
     .build() {
 }
 
-class UpdateEventSourceMappingCommand extends client.Command
+class UpdateEventSourceMappingCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "UpdateEventSourceMapping", {})
     .n("LambdaClient", "UpdateEventSourceMappingCommand")
-    .sc(schemas_0.UpdateEventSourceMapping$)
+    .sc(UpdateEventSourceMapping$)
     .build() {
 }
 
-class UpdateFunctionCodeCommand extends client.Command
+class UpdateFunctionCodeCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "UpdateFunctionCode", {})
     .n("LambdaClient", "UpdateFunctionCodeCommand")
-    .sc(schemas_0.UpdateFunctionCode$)
+    .sc(UpdateFunctionCode$)
     .build() {
 }
 
-class UpdateFunctionConfigurationCommand extends client.Command
+class UpdateFunctionConfigurationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "UpdateFunctionConfiguration", {})
     .n("LambdaClient", "UpdateFunctionConfigurationCommand")
-    .sc(schemas_0.UpdateFunctionConfiguration$)
+    .sc(UpdateFunctionConfiguration$)
     .build() {
 }
 
-class UpdateFunctionEventInvokeConfigCommand extends client.Command
+class UpdateFunctionEventInvokeConfigCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "UpdateFunctionEventInvokeConfig", {})
     .n("LambdaClient", "UpdateFunctionEventInvokeConfigCommand")
-    .sc(schemas_0.UpdateFunctionEventInvokeConfig$)
+    .sc(UpdateFunctionEventInvokeConfig$)
     .build() {
 }
 
-class UpdateFunctionUrlConfigCommand extends client.Command
+class UpdateFunctionUrlConfigCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSGirApiService", "UpdateFunctionUrlConfig", {})
     .n("LambdaClient", "UpdateFunctionUrlConfigCommand")
-    .sc(schemas_0.UpdateFunctionUrlConfig$)
+    .sc(UpdateFunctionUrlConfig$)
     .build() {
 }
 
-const paginateGetDurableExecutionHistory = core.createPaginator(LambdaClient, GetDurableExecutionHistoryCommand, "Marker", "NextMarker", "MaxItems");
+const paginateGetDurableExecutionHistory = createPaginator(LambdaClient, GetDurableExecutionHistoryCommand, "Marker", "NextMarker", "MaxItems");
 
-const paginateGetDurableExecutionState = core.createPaginator(LambdaClient, GetDurableExecutionStateCommand, "Marker", "NextMarker", "MaxItems");
+const paginateGetDurableExecutionState = createPaginator(LambdaClient, GetDurableExecutionStateCommand, "Marker", "NextMarker", "MaxItems");
 
-const paginateListAliases = core.createPaginator(LambdaClient, ListAliasesCommand, "Marker", "NextMarker", "MaxItems");
+const paginateListAliases = createPaginator(LambdaClient, ListAliasesCommand, "Marker", "NextMarker", "MaxItems");
 
-const paginateListCapacityProviders = core.createPaginator(LambdaClient, ListCapacityProvidersCommand, "Marker", "NextMarker", "MaxItems");
+const paginateListCapacityProviders = createPaginator(LambdaClient, ListCapacityProvidersCommand, "Marker", "NextMarker", "MaxItems");
 
-const paginateListCodeSigningConfigs = core.createPaginator(LambdaClient, ListCodeSigningConfigsCommand, "Marker", "NextMarker", "MaxItems");
+const paginateListCodeSigningConfigs = createPaginator(LambdaClient, ListCodeSigningConfigsCommand, "Marker", "NextMarker", "MaxItems");
 
-const paginateListDurableExecutionsByFunction = core.createPaginator(LambdaClient, ListDurableExecutionsByFunctionCommand, "Marker", "NextMarker", "MaxItems");
+const paginateListDurableExecutionsByFunction = createPaginator(LambdaClient, ListDurableExecutionsByFunctionCommand, "Marker", "NextMarker", "MaxItems");
 
-const paginateListEventSourceMappings = core.createPaginator(LambdaClient, ListEventSourceMappingsCommand, "Marker", "NextMarker", "MaxItems");
+const paginateListEventSourceMappings = createPaginator(LambdaClient, ListEventSourceMappingsCommand, "Marker", "NextMarker", "MaxItems");
 
-const paginateListFunctionEventInvokeConfigs = core.createPaginator(LambdaClient, ListFunctionEventInvokeConfigsCommand, "Marker", "NextMarker", "MaxItems");
+const paginateListFunctionEventInvokeConfigs = createPaginator(LambdaClient, ListFunctionEventInvokeConfigsCommand, "Marker", "NextMarker", "MaxItems");
 
-const paginateListFunctionsByCodeSigningConfig = core.createPaginator(LambdaClient, ListFunctionsByCodeSigningConfigCommand, "Marker", "NextMarker", "MaxItems");
+const paginateListFunctionsByCodeSigningConfig = createPaginator(LambdaClient, ListFunctionsByCodeSigningConfigCommand, "Marker", "NextMarker", "MaxItems");
 
-const paginateListFunctions = core.createPaginator(LambdaClient, ListFunctionsCommand, "Marker", "NextMarker", "MaxItems");
+const paginateListFunctions = createPaginator(LambdaClient, ListFunctionsCommand, "Marker", "NextMarker", "MaxItems");
 
-const paginateListFunctionUrlConfigs = core.createPaginator(LambdaClient, ListFunctionUrlConfigsCommand, "Marker", "NextMarker", "MaxItems");
+const paginateListFunctionUrlConfigs = createPaginator(LambdaClient, ListFunctionUrlConfigsCommand, "Marker", "NextMarker", "MaxItems");
 
-const paginateListFunctionVersionsByCapacityProvider = core.createPaginator(LambdaClient, ListFunctionVersionsByCapacityProviderCommand, "Marker", "NextMarker", "MaxItems");
+const paginateListFunctionVersionsByCapacityProvider = createPaginator(LambdaClient, ListFunctionVersionsByCapacityProviderCommand, "Marker", "NextMarker", "MaxItems");
 
-const paginateListLayers = core.createPaginator(LambdaClient, ListLayersCommand, "Marker", "NextMarker", "MaxItems");
+const paginateListLayers = createPaginator(LambdaClient, ListLayersCommand, "Marker", "NextMarker", "MaxItems");
 
-const paginateListLayerVersions = core.createPaginator(LambdaClient, ListLayerVersionsCommand, "Marker", "NextMarker", "MaxItems");
+const paginateListLayerVersions = createPaginator(LambdaClient, ListLayerVersionsCommand, "Marker", "NextMarker", "MaxItems");
 
-const paginateListProvisionedConcurrencyConfigs = core.createPaginator(LambdaClient, ListProvisionedConcurrencyConfigsCommand, "Marker", "NextMarker", "MaxItems");
+const paginateListProvisionedConcurrencyConfigs = createPaginator(LambdaClient, ListProvisionedConcurrencyConfigsCommand, "Marker", "NextMarker", "MaxItems");
 
-const paginateListVersionsByFunction = core.createPaginator(LambdaClient, ListVersionsByFunctionCommand, "Marker", "NextMarker", "MaxItems");
+const paginateListVersionsByFunction = createPaginator(LambdaClient, ListVersionsByFunctionCommand, "Marker", "NextMarker", "MaxItems");
 
-const checkState$5 = async (client$1, input) => {
+const checkState$5 = async (client, input) => {
     let reason;
     try {
-        let result = await client$1.send(new GetFunctionConfigurationCommand(input));
+        let result = await client.send(new GetFunctionConfigurationCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.State;
             };
             if (returnComparator() === "Active") {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1185,7 +1188,7 @@ const checkState$5 = async (client$1, input) => {
                 return result.State;
             };
             if (returnComparator() === "Failed") {
-                return { state: client.WaiterState.FAILURE, reason };
+                return { state: WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -1194,7 +1197,7 @@ const checkState$5 = async (client$1, input) => {
                 return result.State;
             };
             if (returnComparator() === "Pending") {
-                return { state: client.WaiterState.RETRY, reason };
+                return { state: WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -1202,29 +1205,29 @@ const checkState$5 = async (client$1, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForFunctionActive = async (params, input) => {
     const serviceDefaults = { minDelay: 5, maxDelay: 300 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$5);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState$5);
 };
 const waitUntilFunctionActive = async (params, input) => {
     const serviceDefaults = { minDelay: 5, maxDelay: 300 };
-    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$5);
-    return client.checkExceptions(result);
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$5);
+    return checkExceptions(result);
 };
 
-const checkState$4 = async (client$1, input) => {
+const checkState$4 = async (client, input) => {
     let reason;
     try {
-        let result = await client$1.send(new GetFunctionCommand(input));
+        let result = await client.send(new GetFunctionCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.Configuration.State;
             };
             if (returnComparator() === "Active") {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1233,7 +1236,7 @@ const checkState$4 = async (client$1, input) => {
                 return result.Configuration.State;
             };
             if (returnComparator() === "Failed") {
-                return { state: client.WaiterState.FAILURE, reason };
+                return { state: WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -1242,7 +1245,7 @@ const checkState$4 = async (client$1, input) => {
                 return result.Configuration.State;
             };
             if (returnComparator() === "Pending") {
-                return { state: client.WaiterState.RETRY, reason };
+                return { state: WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -1250,54 +1253,54 @@ const checkState$4 = async (client$1, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForFunctionActiveV2 = async (params, input) => {
     const serviceDefaults = { minDelay: 1, maxDelay: 300 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$4);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState$4);
 };
 const waitUntilFunctionActiveV2 = async (params, input) => {
     const serviceDefaults = { minDelay: 1, maxDelay: 300 };
-    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$4);
-    return client.checkExceptions(result);
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$4);
+    return checkExceptions(result);
 };
 
-const checkState$3 = async (client$1, input) => {
+const checkState$3 = async (client, input) => {
     let reason;
     try {
-        let result = await client$1.send(new GetFunctionCommand(input));
+        let result = await client.send(new GetFunctionCommand(input));
         reason = result;
-        return { state: client.WaiterState.SUCCESS, reason };
+        return { state: WaiterState.SUCCESS, reason };
     }
     catch (exception) {
         reason = exception;
         if (exception.name === "ResourceNotFoundException") {
-            return { state: client.WaiterState.RETRY, reason };
+            return { state: WaiterState.RETRY, reason };
         }
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForFunctionExists = async (params, input) => {
     const serviceDefaults = { minDelay: 1, maxDelay: 20 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
 };
 const waitUntilFunctionExists = async (params, input) => {
     const serviceDefaults = { minDelay: 1, maxDelay: 20 };
-    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
-    return client.checkExceptions(result);
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
+    return checkExceptions(result);
 };
 
-const checkState$2 = async (client$1, input) => {
+const checkState$2 = async (client, input) => {
     let reason;
     try {
-        let result = await client$1.send(new GetFunctionConfigurationCommand(input));
+        let result = await client.send(new GetFunctionConfigurationCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.LastUpdateStatus;
             };
             if (returnComparator() === "Successful") {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1306,7 +1309,7 @@ const checkState$2 = async (client$1, input) => {
                 return result.LastUpdateStatus;
             };
             if (returnComparator() === "Failed") {
-                return { state: client.WaiterState.FAILURE, reason };
+                return { state: WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -1315,7 +1318,7 @@ const checkState$2 = async (client$1, input) => {
                 return result.LastUpdateStatus;
             };
             if (returnComparator() === "InProgress") {
-                return { state: client.WaiterState.RETRY, reason };
+                return { state: WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -1323,29 +1326,29 @@ const checkState$2 = async (client$1, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForFunctionUpdated = async (params, input) => {
     const serviceDefaults = { minDelay: 5, maxDelay: 300 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
 };
 const waitUntilFunctionUpdated = async (params, input) => {
     const serviceDefaults = { minDelay: 5, maxDelay: 300 };
-    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
-    return client.checkExceptions(result);
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
+    return checkExceptions(result);
 };
 
-const checkState$1 = async (client$1, input) => {
+const checkState$1 = async (client, input) => {
     let reason;
     try {
-        let result = await client$1.send(new GetFunctionCommand(input));
+        let result = await client.send(new GetFunctionCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.Configuration.LastUpdateStatus;
             };
             if (returnComparator() === "Successful") {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1354,7 +1357,7 @@ const checkState$1 = async (client$1, input) => {
                 return result.Configuration.LastUpdateStatus;
             };
             if (returnComparator() === "Failed") {
-                return { state: client.WaiterState.FAILURE, reason };
+                return { state: WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -1363,7 +1366,7 @@ const checkState$1 = async (client$1, input) => {
                 return result.Configuration.LastUpdateStatus;
             };
             if (returnComparator() === "InProgress") {
-                return { state: client.WaiterState.RETRY, reason };
+                return { state: WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -1371,29 +1374,29 @@ const checkState$1 = async (client$1, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForFunctionUpdatedV2 = async (params, input) => {
     const serviceDefaults = { minDelay: 1, maxDelay: 300 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
 };
 const waitUntilFunctionUpdatedV2 = async (params, input) => {
     const serviceDefaults = { minDelay: 1, maxDelay: 300 };
-    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
-    return client.checkExceptions(result);
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
+    return checkExceptions(result);
 };
 
-const checkState = async (client$1, input) => {
+const checkState = async (client, input) => {
     let reason;
     try {
-        let result = await client$1.send(new GetFunctionConfigurationCommand(input));
+        let result = await client.send(new GetFunctionConfigurationCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.State;
             };
             if (returnComparator() === "Active") {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1402,7 +1405,7 @@ const checkState = async (client$1, input) => {
                 return result.State;
             };
             if (returnComparator() === "Failed") {
-                return { state: client.WaiterState.FAILURE, reason };
+                return { state: WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -1411,7 +1414,7 @@ const checkState = async (client$1, input) => {
                 return result.State;
             };
             if (returnComparator() === "Pending") {
-                return { state: client.WaiterState.RETRY, reason };
+                return { state: WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -1419,16 +1422,16 @@ const checkState = async (client$1, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForPublishedVersionActive = async (params, input) => {
     const serviceDefaults = { minDelay: 5, maxDelay: 1560 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
 const waitUntilPublishedVersionActive = async (params, input) => {
     const serviceDefaults = { minDelay: 5, maxDelay: 1560 };
-    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState);
-    return client.checkExceptions(result);
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
 };
 
 const commands = {
@@ -1546,7 +1549,7 @@ const waiters = {
 };
 class Lambda extends LambdaClient {
 }
-client.createAggregatedClient(commands, Lambda, { paginators, waiters });
+createAggregatedClient(commands, Lambda, { paginators, waiters });
 
 const ThrottleReason = {
     CallerRateLimitExceeded: "CallerRateLimitExceeded",
@@ -1789,6 +1792,7 @@ const LastUpdateStatusReasonCode = {
     InvalidZipFileException: "InvalidZipFileException",
     KMSKeyAccessDenied: "KMSKeyAccessDenied",
     KMSKeyNotFound: "KMSKeyNotFound",
+    ServiceQuotaExceededException: "ServiceQuotaExceededException",
     SubnetOutOfIPAddresses: "SubnetOutOfIPAddresses",
     VcpuLimitExceeded: "VcpuLimitExceeded",
 };
@@ -1833,6 +1837,7 @@ const StateReasonCode = {
     KMSKeyAccessDenied: "KMSKeyAccessDenied",
     KMSKeyNotFound: "KMSKeyNotFound",
     Restoring: "Restoring",
+    ServiceQuotaExceededException: "ServiceQuotaExceededException",
     SubnetOutOfIPAddresses: "SubnetOutOfIPAddresses",
     VcpuLimitExceeded: "VcpuLimitExceeded",
 };
@@ -1904,9 +1909,6 @@ const EventType = {
     WaitSucceeded: "WaitSucceeded",
 };
 
-exports.$Command = client.Command;
-exports.__Client = client.Client;
-exports.LambdaServiceException = LambdaServiceException.LambdaServiceException;
 exports.AddLayerVersionPermissionCommand = AddLayerVersionPermissionCommand;
 exports.AddPermissionCommand = AddPermissionCommand;
 exports.ApplicationLogLevel = ApplicationLogLevel;
@@ -2067,23 +2069,3 @@ exports.waitUntilFunctionExists = waitUntilFunctionExists;
 exports.waitUntilFunctionUpdated = waitUntilFunctionUpdated;
 exports.waitUntilFunctionUpdatedV2 = waitUntilFunctionUpdatedV2;
 exports.waitUntilPublishedVersionActive = waitUntilPublishedVersionActive;
-Object.prototype.hasOwnProperty.call(schemas_0, '__proto__') &&
-    !Object.prototype.hasOwnProperty.call(exports, '__proto__') &&
-    Object.defineProperty(exports, '__proto__', {
-        enumerable: true,
-        value: schemas_0['__proto__']
-    });
-
-Object.keys(schemas_0).forEach(function (k) {
-    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = schemas_0[k];
-});
-Object.prototype.hasOwnProperty.call(errors, '__proto__') &&
-    !Object.prototype.hasOwnProperty.call(exports, '__proto__') &&
-    Object.defineProperty(exports, '__proto__', {
-        enumerable: true,
-        value: errors['__proto__']
-    });
-
-Object.keys(errors).forEach(function (k) {
-    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = errors[k];
-});