@aws-sdk/client-medialive 3.1044.0 → 3.1046.0

package/dist-cjs/index.js

@@ -4,19 +4,17 @@ var middlewareHostHeader = require('@aws-sdk/middleware-host-header');
 var middlewareLogger = require('@aws-sdk/middleware-logger');
 var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detection');
 var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
-var configResolver = require('@smithy/config-resolver');
 var core = require('@smithy/core');
+var client = require('@smithy/core/client');
+var config = require('@smithy/core/config');
+var endpoints = require('@smithy/core/endpoints');
+var protocols = require('@smithy/core/protocols');
+var retry = require('@smithy/core/retry');
 var schema = require('@smithy/core/schema');
-var middlewareContentLength = require('@smithy/middleware-content-length');
-var middlewareEndpoint = require('@smithy/middleware-endpoint');
-var middlewareRetry = require('@smithy/middleware-retry');
-var smithyClient = require('@smithy/smithy-client');
 var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
 var runtimeConfig = require('./runtimeConfig');
 var regionConfigResolver = require('@aws-sdk/region-config-resolver');
-var protocolHttp = require('@smithy/protocol-http');
 var schemas_0 = require('./schemas/schemas_0');
-var utilWaiter = require('@smithy/util-waiter');
 var errors = require('./models/errors');
 var MediaLiveServiceException = require('./models/MediaLiveServiceException');
 
@@ -74,12 +72,12 @@ const resolveHttpAuthRuntimeConfig = (config) => {
 };
 
 const resolveRuntimeExtensions = (runtimeConfig, extensions) => {
-    const extensionConfiguration = Object.assign(regionConfigResolver.getAwsRegionExtensionConfiguration(runtimeConfig), smithyClient.getDefaultExtensionConfiguration(runtimeConfig), protocolHttp.getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
+    const extensionConfiguration = Object.assign(regionConfigResolver.getAwsRegionExtensionConfiguration(runtimeConfig), client.getDefaultExtensionConfiguration(runtimeConfig), protocols.getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
     extensions.forEach((extension) => extension.configure(extensionConfiguration));
-    return Object.assign(runtimeConfig, regionConfigResolver.resolveAwsRegionExtensionConfiguration(extensionConfiguration), smithyClient.resolveDefaultRuntimeConfig(extensionConfiguration), protocolHttp.resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
+    return Object.assign(runtimeConfig, regionConfigResolver.resolveAwsRegionExtensionConfiguration(extensionConfiguration), client.resolveDefaultRuntimeConfig(extensionConfiguration), protocols.resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
 };
 
-class MediaLiveClient extends smithyClient.Client {
+class MediaLiveClient extends client.Client {
     config;
     constructor(...[configuration]) {
         const _config_0 = runtimeConfig.getRuntimeConfig(configuration || {});
@@ -87,17 +85,17 @@ class MediaLiveClient extends smithyClient.Client {
         this.initConfig = _config_0;
         const _config_1 = resolveClientEndpointParameters(_config_0);
         const _config_2 = middlewareUserAgent.resolveUserAgentConfig(_config_1);
-        const _config_3 = middlewareRetry.resolveRetryConfig(_config_2);
-        const _config_4 = configResolver.resolveRegionConfig(_config_3);
+        const _config_3 = retry.resolveRetryConfig(_config_2);
+        const _config_4 = config.resolveRegionConfig(_config_3);
         const _config_5 = middlewareHostHeader.resolveHostHeaderConfig(_config_4);
-        const _config_6 = middlewareEndpoint.resolveEndpointConfig(_config_5);
+        const _config_6 = endpoints.resolveEndpointConfig(_config_5);
         const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
         const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
         this.config = _config_8;
         this.middlewareStack.use(schema.getSchemaSerdePlugin(this.config));
         this.middlewareStack.use(middlewareUserAgent.getUserAgentPlugin(this.config));
-        this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
-        this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
+        this.middlewareStack.use(retry.getRetryPlugin(this.config));
+        this.middlewareStack.use(protocols.getContentLengthPlugin(this.config));
         this.middlewareStack.use(middlewareHostHeader.getHostHeaderPlugin(this.config));
         this.middlewareStack.use(middlewareLogger.getLoggerPlugin(this.config));
         this.middlewareStack.use(middlewareRecursionDetection.getRecursionDetectionPlugin(this.config));
@@ -114,11 +112,11 @@ class MediaLiveClient extends smithyClient.Client {
     }
 }
 
-class AcceptInputDeviceTransferCommand extends smithyClient.Command
+class AcceptInputDeviceTransferCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "AcceptInputDeviceTransfer", {})
     .n("MediaLiveClient", "AcceptInputDeviceTransferCommand")
@@ -126,11 +124,11 @@ class AcceptInputDeviceTransferCommand extends smithyClient.Command
     .build() {
 }
 
-class BatchDeleteCommand extends smithyClient.Command
+class BatchDeleteCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "BatchDelete", {})
     .n("MediaLiveClient", "BatchDeleteCommand")
@@ -138,11 +136,11 @@ class BatchDeleteCommand extends smithyClient.Command
     .build() {
 }
 
-class BatchStartCommand extends smithyClient.Command
+class BatchStartCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "BatchStart", {})
     .n("MediaLiveClient", "BatchStartCommand")
@@ -150,11 +148,11 @@ class BatchStartCommand extends smithyClient.Command
     .build() {
 }
 
-class BatchStopCommand extends smithyClient.Command
+class BatchStopCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "BatchStop", {})
     .n("MediaLiveClient", "BatchStopCommand")
@@ -162,11 +160,11 @@ class BatchStopCommand extends smithyClient.Command
     .build() {
 }
 
-class BatchUpdateScheduleCommand extends smithyClient.Command
+class BatchUpdateScheduleCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "BatchUpdateSchedule", {})
     .n("MediaLiveClient", "BatchUpdateScheduleCommand")
@@ -174,11 +172,11 @@ class BatchUpdateScheduleCommand extends smithyClient.Command
     .build() {
 }
 
-class CancelInputDeviceTransferCommand extends smithyClient.Command
+class CancelInputDeviceTransferCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "CancelInputDeviceTransfer", {})
     .n("MediaLiveClient", "CancelInputDeviceTransferCommand")
@@ -186,11 +184,11 @@ class CancelInputDeviceTransferCommand extends smithyClient.Command
     .build() {
 }
 
-class ClaimDeviceCommand extends smithyClient.Command
+class ClaimDeviceCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "ClaimDevice", {})
     .n("MediaLiveClient", "ClaimDeviceCommand")
@@ -198,11 +196,11 @@ class ClaimDeviceCommand extends smithyClient.Command
     .build() {
 }
 
-class CreateChannelCommand extends smithyClient.Command
+class CreateChannelCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "CreateChannel", {})
     .n("MediaLiveClient", "CreateChannelCommand")
@@ -210,11 +208,11 @@ class CreateChannelCommand extends smithyClient.Command
     .build() {
 }
 
-class CreateChannelPlacementGroupCommand extends smithyClient.Command
+class CreateChannelPlacementGroupCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "CreateChannelPlacementGroup", {})
     .n("MediaLiveClient", "CreateChannelPlacementGroupCommand")
@@ -222,11 +220,11 @@ class CreateChannelPlacementGroupCommand extends smithyClient.Command
     .build() {
 }
 
-class CreateCloudWatchAlarmTemplateCommand extends smithyClient.Command
+class CreateCloudWatchAlarmTemplateCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "CreateCloudWatchAlarmTemplate", {})
     .n("MediaLiveClient", "CreateCloudWatchAlarmTemplateCommand")
@@ -234,11 +232,11 @@ class CreateCloudWatchAlarmTemplateCommand extends smithyClient.Command
     .build() {
 }
 
-class CreateCloudWatchAlarmTemplateGroupCommand extends smithyClient.Command
+class CreateCloudWatchAlarmTemplateGroupCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "CreateCloudWatchAlarmTemplateGroup", {})
     .n("MediaLiveClient", "CreateCloudWatchAlarmTemplateGroupCommand")
@@ -246,11 +244,11 @@ class CreateCloudWatchAlarmTemplateGroupCommand extends smithyClient.Command
     .build() {
 }
 
-class CreateClusterCommand extends smithyClient.Command
+class CreateClusterCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "CreateCluster", {})
     .n("MediaLiveClient", "CreateClusterCommand")
@@ -258,11 +256,11 @@ class CreateClusterCommand extends smithyClient.Command
     .build() {
 }
 
-class CreateEventBridgeRuleTemplateCommand extends smithyClient.Command
+class CreateEventBridgeRuleTemplateCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "CreateEventBridgeRuleTemplate", {})
     .n("MediaLiveClient", "CreateEventBridgeRuleTemplateCommand")
@@ -270,11 +268,11 @@ class CreateEventBridgeRuleTemplateCommand extends smithyClient.Command
     .build() {
 }
 
-class CreateEventBridgeRuleTemplateGroupCommand extends smithyClient.Command
+class CreateEventBridgeRuleTemplateGroupCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "CreateEventBridgeRuleTemplateGroup", {})
     .n("MediaLiveClient", "CreateEventBridgeRuleTemplateGroupCommand")
@@ -282,11 +280,11 @@ class CreateEventBridgeRuleTemplateGroupCommand extends smithyClient.Command
     .build() {
 }
 
-class CreateInputCommand extends smithyClient.Command
+class CreateInputCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "CreateInput", {})
     .n("MediaLiveClient", "CreateInputCommand")
@@ -294,11 +292,11 @@ class CreateInputCommand extends smithyClient.Command
     .build() {
 }
 
-class CreateInputSecurityGroupCommand extends smithyClient.Command
+class CreateInputSecurityGroupCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "CreateInputSecurityGroup", {})
     .n("MediaLiveClient", "CreateInputSecurityGroupCommand")
@@ -306,11 +304,11 @@ class CreateInputSecurityGroupCommand extends smithyClient.Command
     .build() {
 }
 
-class CreateMultiplexCommand extends smithyClient.Command
+class CreateMultiplexCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "CreateMultiplex", {})
     .n("MediaLiveClient", "CreateMultiplexCommand")
@@ -318,11 +316,11 @@ class CreateMultiplexCommand extends smithyClient.Command
     .build() {
 }
 
-class CreateMultiplexProgramCommand extends smithyClient.Command
+class CreateMultiplexProgramCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "CreateMultiplexProgram", {})
     .n("MediaLiveClient", "CreateMultiplexProgramCommand")
@@ -330,11 +328,11 @@ class CreateMultiplexProgramCommand extends smithyClient.Command
     .build() {
 }
 
-class CreateNetworkCommand extends smithyClient.Command
+class CreateNetworkCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "CreateNetwork", {})
     .n("MediaLiveClient", "CreateNetworkCommand")
@@ -342,11 +340,11 @@ class CreateNetworkCommand extends smithyClient.Command
     .build() {
 }
 
-class CreateNodeCommand extends smithyClient.Command
+class CreateNodeCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "CreateNode", {})
     .n("MediaLiveClient", "CreateNodeCommand")
@@ -354,11 +352,11 @@ class CreateNodeCommand extends smithyClient.Command
     .build() {
 }
 
-class CreateNodeRegistrationScriptCommand extends smithyClient.Command
+class CreateNodeRegistrationScriptCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "CreateNodeRegistrationScript", {})
     .n("MediaLiveClient", "CreateNodeRegistrationScriptCommand")
@@ -366,11 +364,11 @@ class CreateNodeRegistrationScriptCommand extends smithyClient.Command
     .build() {
 }
 
-class CreatePartnerInputCommand extends smithyClient.Command
+class CreatePartnerInputCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "CreatePartnerInput", {})
     .n("MediaLiveClient", "CreatePartnerInputCommand")
@@ -378,11 +376,11 @@ class CreatePartnerInputCommand extends smithyClient.Command
     .build() {
 }
 
-class CreateSdiSourceCommand extends smithyClient.Command
+class CreateSdiSourceCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "CreateSdiSource", {})
     .n("MediaLiveClient", "CreateSdiSourceCommand")
@@ -390,11 +388,11 @@ class CreateSdiSourceCommand extends smithyClient.Command
     .build() {
 }
 
-class CreateSignalMapCommand extends smithyClient.Command
+class CreateSignalMapCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "CreateSignalMap", {})
     .n("MediaLiveClient", "CreateSignalMapCommand")
@@ -402,11 +400,11 @@ class CreateSignalMapCommand extends smithyClient.Command
     .build() {
 }
 
-class CreateTagsCommand extends smithyClient.Command
+class CreateTagsCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "CreateTags", {})
     .n("MediaLiveClient", "CreateTagsCommand")
@@ -414,11 +412,11 @@ class CreateTagsCommand extends smithyClient.Command
     .build() {
 }
 
-class DeleteChannelCommand extends smithyClient.Command
+class DeleteChannelCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "DeleteChannel", {})
     .n("MediaLiveClient", "DeleteChannelCommand")
@@ -426,11 +424,11 @@ class DeleteChannelCommand extends smithyClient.Command
     .build() {
 }
 
-class DeleteChannelPlacementGroupCommand extends smithyClient.Command
+class DeleteChannelPlacementGroupCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "DeleteChannelPlacementGroup", {})
     .n("MediaLiveClient", "DeleteChannelPlacementGroupCommand")
@@ -438,11 +436,11 @@ class DeleteChannelPlacementGroupCommand extends smithyClient.Command
     .build() {
 }
 
-class DeleteCloudWatchAlarmTemplateCommand extends smithyClient.Command
+class DeleteCloudWatchAlarmTemplateCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "DeleteCloudWatchAlarmTemplate", {})
     .n("MediaLiveClient", "DeleteCloudWatchAlarmTemplateCommand")
@@ -450,11 +448,11 @@ class DeleteCloudWatchAlarmTemplateCommand extends smithyClient.Command
     .build() {
 }
 
-class DeleteCloudWatchAlarmTemplateGroupCommand extends smithyClient.Command
+class DeleteCloudWatchAlarmTemplateGroupCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "DeleteCloudWatchAlarmTemplateGroup", {})
     .n("MediaLiveClient", "DeleteCloudWatchAlarmTemplateGroupCommand")
@@ -462,11 +460,11 @@ class DeleteCloudWatchAlarmTemplateGroupCommand extends smithyClient.Command
     .build() {
 }
 
-class DeleteClusterCommand extends smithyClient.Command
+class DeleteClusterCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "DeleteCluster", {})
     .n("MediaLiveClient", "DeleteClusterCommand")
@@ -474,11 +472,11 @@ class DeleteClusterCommand extends smithyClient.Command
     .build() {
 }
 
-class DeleteEventBridgeRuleTemplateCommand extends smithyClient.Command
+class DeleteEventBridgeRuleTemplateCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "DeleteEventBridgeRuleTemplate", {})
     .n("MediaLiveClient", "DeleteEventBridgeRuleTemplateCommand")
@@ -486,11 +484,11 @@ class DeleteEventBridgeRuleTemplateCommand extends smithyClient.Command
     .build() {
 }
 
-class DeleteEventBridgeRuleTemplateGroupCommand extends smithyClient.Command
+class DeleteEventBridgeRuleTemplateGroupCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "DeleteEventBridgeRuleTemplateGroup", {})
     .n("MediaLiveClient", "DeleteEventBridgeRuleTemplateGroupCommand")
@@ -498,11 +496,11 @@ class DeleteEventBridgeRuleTemplateGroupCommand extends smithyClient.Command
     .build() {
 }
 
-class DeleteInputCommand extends smithyClient.Command
+class DeleteInputCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "DeleteInput", {})
     .n("MediaLiveClient", "DeleteInputCommand")
@@ -510,11 +508,11 @@ class DeleteInputCommand extends smithyClient.Command
     .build() {
 }
 
-class DeleteInputSecurityGroupCommand extends smithyClient.Command
+class DeleteInputSecurityGroupCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "DeleteInputSecurityGroup", {})
     .n("MediaLiveClient", "DeleteInputSecurityGroupCommand")
@@ -522,11 +520,11 @@ class DeleteInputSecurityGroupCommand extends smithyClient.Command
     .build() {
 }
 
-class DeleteMultiplexCommand extends smithyClient.Command
+class DeleteMultiplexCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "DeleteMultiplex", {})
     .n("MediaLiveClient", "DeleteMultiplexCommand")
@@ -534,11 +532,11 @@ class DeleteMultiplexCommand extends smithyClient.Command
     .build() {
 }
 
-class DeleteMultiplexProgramCommand extends smithyClient.Command
+class DeleteMultiplexProgramCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "DeleteMultiplexProgram", {})
     .n("MediaLiveClient", "DeleteMultiplexProgramCommand")
@@ -546,11 +544,11 @@ class DeleteMultiplexProgramCommand extends smithyClient.Command
     .build() {
 }
 
-class DeleteNetworkCommand extends smithyClient.Command
+class DeleteNetworkCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "DeleteNetwork", {})
     .n("MediaLiveClient", "DeleteNetworkCommand")
@@ -558,11 +556,11 @@ class DeleteNetworkCommand extends smithyClient.Command
     .build() {
 }
 
-class DeleteNodeCommand extends smithyClient.Command
+class DeleteNodeCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "DeleteNode", {})
     .n("MediaLiveClient", "DeleteNodeCommand")
@@ -570,11 +568,11 @@ class DeleteNodeCommand extends smithyClient.Command
     .build() {
 }
 
-class DeleteReservationCommand extends smithyClient.Command
+class DeleteReservationCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "DeleteReservation", {})
     .n("MediaLiveClient", "DeleteReservationCommand")
@@ -582,11 +580,11 @@ class DeleteReservationCommand extends smithyClient.Command
     .build() {
 }
 
-class DeleteScheduleCommand extends smithyClient.Command
+class DeleteScheduleCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "DeleteSchedule", {})
     .n("MediaLiveClient", "DeleteScheduleCommand")
@@ -594,11 +592,11 @@ class DeleteScheduleCommand extends smithyClient.Command
     .build() {
 }
 
-class DeleteSdiSourceCommand extends smithyClient.Command
+class DeleteSdiSourceCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "DeleteSdiSource", {})
     .n("MediaLiveClient", "DeleteSdiSourceCommand")
@@ -606,11 +604,11 @@ class DeleteSdiSourceCommand extends smithyClient.Command
     .build() {
 }
 
-class DeleteSignalMapCommand extends smithyClient.Command
+class DeleteSignalMapCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "DeleteSignalMap", {})
     .n("MediaLiveClient", "DeleteSignalMapCommand")
@@ -618,11 +616,11 @@ class DeleteSignalMapCommand extends smithyClient.Command
     .build() {
 }
 
-class DeleteTagsCommand extends smithyClient.Command
+class DeleteTagsCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "DeleteTags", {})
     .n("MediaLiveClient", "DeleteTagsCommand")
@@ -630,11 +628,11 @@ class DeleteTagsCommand extends smithyClient.Command
     .build() {
 }
 
-class DescribeAccountConfigurationCommand extends smithyClient.Command
+class DescribeAccountConfigurationCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "DescribeAccountConfiguration", {})
     .n("MediaLiveClient", "DescribeAccountConfigurationCommand")
@@ -642,11 +640,11 @@ class DescribeAccountConfigurationCommand extends smithyClient.Command
     .build() {
 }
 
-class DescribeChannelCommand extends smithyClient.Command
+class DescribeChannelCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "DescribeChannel", {})
     .n("MediaLiveClient", "DescribeChannelCommand")
@@ -654,11 +652,11 @@ class DescribeChannelCommand extends smithyClient.Command
     .build() {
 }
 
-class DescribeChannelPlacementGroupCommand extends smithyClient.Command
+class DescribeChannelPlacementGroupCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "DescribeChannelPlacementGroup", {})
     .n("MediaLiveClient", "DescribeChannelPlacementGroupCommand")
@@ -666,11 +664,11 @@ class DescribeChannelPlacementGroupCommand extends smithyClient.Command
     .build() {
 }
 
-class DescribeClusterCommand extends smithyClient.Command
+class DescribeClusterCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "DescribeCluster", {})
     .n("MediaLiveClient", "DescribeClusterCommand")
@@ -678,11 +676,11 @@ class DescribeClusterCommand extends smithyClient.Command
     .build() {
 }
 
-class DescribeInputCommand extends smithyClient.Command
+class DescribeInputCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "DescribeInput", {})
     .n("MediaLiveClient", "DescribeInputCommand")
@@ -690,11 +688,11 @@ class DescribeInputCommand extends smithyClient.Command
     .build() {
 }
 
-class DescribeInputDeviceCommand extends smithyClient.Command
+class DescribeInputDeviceCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "DescribeInputDevice", {})
     .n("MediaLiveClient", "DescribeInputDeviceCommand")
@@ -702,11 +700,11 @@ class DescribeInputDeviceCommand extends smithyClient.Command
     .build() {
 }
 
-class DescribeInputDeviceThumbnailCommand extends smithyClient.Command
+class DescribeInputDeviceThumbnailCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "DescribeInputDeviceThumbnail", {})
     .n("MediaLiveClient", "DescribeInputDeviceThumbnailCommand")
@@ -714,11 +712,11 @@ class DescribeInputDeviceThumbnailCommand extends smithyClient.Command
     .build() {
 }
 
-class DescribeInputSecurityGroupCommand extends smithyClient.Command
+class DescribeInputSecurityGroupCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "DescribeInputSecurityGroup", {})
     .n("MediaLiveClient", "DescribeInputSecurityGroupCommand")
@@ -726,11 +724,11 @@ class DescribeInputSecurityGroupCommand extends smithyClient.Command
     .build() {
 }
 
-class DescribeMultiplexCommand extends smithyClient.Command
+class DescribeMultiplexCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "DescribeMultiplex", {})
     .n("MediaLiveClient", "DescribeMultiplexCommand")
@@ -738,11 +736,11 @@ class DescribeMultiplexCommand extends smithyClient.Command
     .build() {
 }
 
-class DescribeMultiplexProgramCommand extends smithyClient.Command
+class DescribeMultiplexProgramCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "DescribeMultiplexProgram", {})
     .n("MediaLiveClient", "DescribeMultiplexProgramCommand")
@@ -750,11 +748,11 @@ class DescribeMultiplexProgramCommand extends smithyClient.Command
     .build() {
 }
 
-class DescribeNetworkCommand extends smithyClient.Command
+class DescribeNetworkCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "DescribeNetwork", {})
     .n("MediaLiveClient", "DescribeNetworkCommand")
@@ -762,11 +760,11 @@ class DescribeNetworkCommand extends smithyClient.Command
     .build() {
 }
 
-class DescribeNodeCommand extends smithyClient.Command
+class DescribeNodeCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "DescribeNode", {})
     .n("MediaLiveClient", "DescribeNodeCommand")
@@ -774,11 +772,11 @@ class DescribeNodeCommand extends smithyClient.Command
     .build() {
 }
 
-class DescribeOfferingCommand extends smithyClient.Command
+class DescribeOfferingCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "DescribeOffering", {})
     .n("MediaLiveClient", "DescribeOfferingCommand")
@@ -786,11 +784,11 @@ class DescribeOfferingCommand extends smithyClient.Command
     .build() {
 }
 
-class DescribeReservationCommand extends smithyClient.Command
+class DescribeReservationCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "DescribeReservation", {})
     .n("MediaLiveClient", "DescribeReservationCommand")
@@ -798,11 +796,11 @@ class DescribeReservationCommand extends smithyClient.Command
     .build() {
 }
 
-class DescribeScheduleCommand extends smithyClient.Command
+class DescribeScheduleCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "DescribeSchedule", {})
     .n("MediaLiveClient", "DescribeScheduleCommand")
@@ -810,11 +808,11 @@ class DescribeScheduleCommand extends smithyClient.Command
     .build() {
 }
 
-class DescribeSdiSourceCommand extends smithyClient.Command
+class DescribeSdiSourceCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "DescribeSdiSource", {})
     .n("MediaLiveClient", "DescribeSdiSourceCommand")
@@ -822,11 +820,11 @@ class DescribeSdiSourceCommand extends smithyClient.Command
     .build() {
 }
 
-class DescribeThumbnailsCommand extends smithyClient.Command
+class DescribeThumbnailsCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "DescribeThumbnails", {})
     .n("MediaLiveClient", "DescribeThumbnailsCommand")
@@ -834,11 +832,11 @@ class DescribeThumbnailsCommand extends smithyClient.Command
     .build() {
 }
 
-class GetCloudWatchAlarmTemplateCommand extends smithyClient.Command
+class GetCloudWatchAlarmTemplateCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "GetCloudWatchAlarmTemplate", {})
     .n("MediaLiveClient", "GetCloudWatchAlarmTemplateCommand")
@@ -846,11 +844,11 @@ class GetCloudWatchAlarmTemplateCommand extends smithyClient.Command
     .build() {
 }
 
-class GetCloudWatchAlarmTemplateGroupCommand extends smithyClient.Command
+class GetCloudWatchAlarmTemplateGroupCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "GetCloudWatchAlarmTemplateGroup", {})
     .n("MediaLiveClient", "GetCloudWatchAlarmTemplateGroupCommand")
@@ -858,11 +856,11 @@ class GetCloudWatchAlarmTemplateGroupCommand extends smithyClient.Command
     .build() {
 }
 
-class GetEventBridgeRuleTemplateCommand extends smithyClient.Command
+class GetEventBridgeRuleTemplateCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "GetEventBridgeRuleTemplate", {})
     .n("MediaLiveClient", "GetEventBridgeRuleTemplateCommand")
@@ -870,11 +868,11 @@ class GetEventBridgeRuleTemplateCommand extends smithyClient.Command
     .build() {
 }
 
-class GetEventBridgeRuleTemplateGroupCommand extends smithyClient.Command
+class GetEventBridgeRuleTemplateGroupCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "GetEventBridgeRuleTemplateGroup", {})
     .n("MediaLiveClient", "GetEventBridgeRuleTemplateGroupCommand")
@@ -882,11 +880,11 @@ class GetEventBridgeRuleTemplateGroupCommand extends smithyClient.Command
     .build() {
 }
 
-class GetSignalMapCommand extends smithyClient.Command
+class GetSignalMapCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "GetSignalMap", {})
     .n("MediaLiveClient", "GetSignalMapCommand")
@@ -894,11 +892,11 @@ class GetSignalMapCommand extends smithyClient.Command
     .build() {
 }
 
-class ListAlertsCommand extends smithyClient.Command
+class ListAlertsCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "ListAlerts", {})
     .n("MediaLiveClient", "ListAlertsCommand")
@@ -906,11 +904,11 @@ class ListAlertsCommand extends smithyClient.Command
     .build() {
 }
 
-class ListChannelPlacementGroupsCommand extends smithyClient.Command
+class ListChannelPlacementGroupsCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "ListChannelPlacementGroups", {})
     .n("MediaLiveClient", "ListChannelPlacementGroupsCommand")
@@ -918,11 +916,11 @@ class ListChannelPlacementGroupsCommand extends smithyClient.Command
     .build() {
 }
 
-class ListChannelsCommand extends smithyClient.Command
+class ListChannelsCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "ListChannels", {})
     .n("MediaLiveClient", "ListChannelsCommand")
@@ -930,11 +928,11 @@ class ListChannelsCommand extends smithyClient.Command
     .build() {
 }
 
-class ListCloudWatchAlarmTemplateGroupsCommand extends smithyClient.Command
+class ListCloudWatchAlarmTemplateGroupsCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "ListCloudWatchAlarmTemplateGroups", {})
     .n("MediaLiveClient", "ListCloudWatchAlarmTemplateGroupsCommand")
@@ -942,11 +940,11 @@ class ListCloudWatchAlarmTemplateGroupsCommand extends smithyClient.Command
     .build() {
 }
 
-class ListCloudWatchAlarmTemplatesCommand extends smithyClient.Command
+class ListCloudWatchAlarmTemplatesCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "ListCloudWatchAlarmTemplates", {})
     .n("MediaLiveClient", "ListCloudWatchAlarmTemplatesCommand")
@@ -954,11 +952,11 @@ class ListCloudWatchAlarmTemplatesCommand extends smithyClient.Command
     .build() {
 }
 
-class ListClusterAlertsCommand extends smithyClient.Command
+class ListClusterAlertsCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "ListClusterAlerts", {})
     .n("MediaLiveClient", "ListClusterAlertsCommand")
@@ -966,11 +964,11 @@ class ListClusterAlertsCommand extends smithyClient.Command
     .build() {
 }
 
-class ListClustersCommand extends smithyClient.Command
+class ListClustersCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "ListClusters", {})
     .n("MediaLiveClient", "ListClustersCommand")
@@ -978,11 +976,11 @@ class ListClustersCommand extends smithyClient.Command
     .build() {
 }
 
-class ListEventBridgeRuleTemplateGroupsCommand extends smithyClient.Command
+class ListEventBridgeRuleTemplateGroupsCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "ListEventBridgeRuleTemplateGroups", {})
     .n("MediaLiveClient", "ListEventBridgeRuleTemplateGroupsCommand")
@@ -990,11 +988,11 @@ class ListEventBridgeRuleTemplateGroupsCommand extends smithyClient.Command
     .build() {
 }
 
-class ListEventBridgeRuleTemplatesCommand extends smithyClient.Command
+class ListEventBridgeRuleTemplatesCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "ListEventBridgeRuleTemplates", {})
     .n("MediaLiveClient", "ListEventBridgeRuleTemplatesCommand")
@@ -1002,11 +1000,11 @@ class ListEventBridgeRuleTemplatesCommand extends smithyClient.Command
     .build() {
 }
 
-class ListInputDevicesCommand extends smithyClient.Command
+class ListInputDevicesCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "ListInputDevices", {})
     .n("MediaLiveClient", "ListInputDevicesCommand")
@@ -1014,11 +1012,11 @@ class ListInputDevicesCommand extends smithyClient.Command
     .build() {
 }
 
-class ListInputDeviceTransfersCommand extends smithyClient.Command
+class ListInputDeviceTransfersCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "ListInputDeviceTransfers", {})
     .n("MediaLiveClient", "ListInputDeviceTransfersCommand")
@@ -1026,11 +1024,11 @@ class ListInputDeviceTransfersCommand extends smithyClient.Command
     .build() {
 }
 
-class ListInputsCommand extends smithyClient.Command
+class ListInputsCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "ListInputs", {})
     .n("MediaLiveClient", "ListInputsCommand")
@@ -1038,11 +1036,11 @@ class ListInputsCommand extends smithyClient.Command
     .build() {
 }
 
-class ListInputSecurityGroupsCommand extends smithyClient.Command
+class ListInputSecurityGroupsCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "ListInputSecurityGroups", {})
     .n("MediaLiveClient", "ListInputSecurityGroupsCommand")
@@ -1050,11 +1048,11 @@ class ListInputSecurityGroupsCommand extends smithyClient.Command
     .build() {
 }
 
-class ListMultiplexAlertsCommand extends smithyClient.Command
+class ListMultiplexAlertsCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "ListMultiplexAlerts", {})
     .n("MediaLiveClient", "ListMultiplexAlertsCommand")
@@ -1062,11 +1060,11 @@ class ListMultiplexAlertsCommand extends smithyClient.Command
     .build() {
 }
 
-class ListMultiplexesCommand extends smithyClient.Command
+class ListMultiplexesCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "ListMultiplexes", {})
     .n("MediaLiveClient", "ListMultiplexesCommand")
@@ -1074,11 +1072,11 @@ class ListMultiplexesCommand extends smithyClient.Command
     .build() {
 }
 
-class ListMultiplexProgramsCommand extends smithyClient.Command
+class ListMultiplexProgramsCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "ListMultiplexPrograms", {})
     .n("MediaLiveClient", "ListMultiplexProgramsCommand")
@@ -1086,11 +1084,11 @@ class ListMultiplexProgramsCommand extends smithyClient.Command
     .build() {
 }
 
-class ListNetworksCommand extends smithyClient.Command
+class ListNetworksCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "ListNetworks", {})
     .n("MediaLiveClient", "ListNetworksCommand")
@@ -1098,11 +1096,11 @@ class ListNetworksCommand extends smithyClient.Command
     .build() {
 }
 
-class ListNodesCommand extends smithyClient.Command
+class ListNodesCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "ListNodes", {})
     .n("MediaLiveClient", "ListNodesCommand")
@@ -1110,11 +1108,11 @@ class ListNodesCommand extends smithyClient.Command
     .build() {
 }
 
-class ListOfferingsCommand extends smithyClient.Command
+class ListOfferingsCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "ListOfferings", {})
     .n("MediaLiveClient", "ListOfferingsCommand")
@@ -1122,11 +1120,11 @@ class ListOfferingsCommand extends smithyClient.Command
     .build() {
 }
 
-class ListReservationsCommand extends smithyClient.Command
+class ListReservationsCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "ListReservations", {})
     .n("MediaLiveClient", "ListReservationsCommand")
@@ -1134,11 +1132,11 @@ class ListReservationsCommand extends smithyClient.Command
     .build() {
 }
 
-class ListSdiSourcesCommand extends smithyClient.Command
+class ListSdiSourcesCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "ListSdiSources", {})
     .n("MediaLiveClient", "ListSdiSourcesCommand")
@@ -1146,11 +1144,11 @@ class ListSdiSourcesCommand extends smithyClient.Command
     .build() {
 }
 
-class ListSignalMapsCommand extends smithyClient.Command
+class ListSignalMapsCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "ListSignalMaps", {})
     .n("MediaLiveClient", "ListSignalMapsCommand")
@@ -1158,11 +1156,11 @@ class ListSignalMapsCommand extends smithyClient.Command
     .build() {
 }
 
-class ListTagsForResourceCommand extends smithyClient.Command
+class ListTagsForResourceCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "ListTagsForResource", {})
     .n("MediaLiveClient", "ListTagsForResourceCommand")
@@ -1170,11 +1168,11 @@ class ListTagsForResourceCommand extends smithyClient.Command
     .build() {
 }
 
-class ListVersionsCommand extends smithyClient.Command
+class ListVersionsCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "ListVersions", {})
     .n("MediaLiveClient", "ListVersionsCommand")
@@ -1182,11 +1180,11 @@ class ListVersionsCommand extends smithyClient.Command
     .build() {
 }
 
-class PurchaseOfferingCommand extends smithyClient.Command
+class PurchaseOfferingCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "PurchaseOffering", {})
     .n("MediaLiveClient", "PurchaseOfferingCommand")
@@ -1194,11 +1192,11 @@ class PurchaseOfferingCommand extends smithyClient.Command
     .build() {
 }
 
-class RebootInputDeviceCommand extends smithyClient.Command
+class RebootInputDeviceCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "RebootInputDevice", {})
     .n("MediaLiveClient", "RebootInputDeviceCommand")
@@ -1206,11 +1204,11 @@ class RebootInputDeviceCommand extends smithyClient.Command
     .build() {
 }
 
-class RejectInputDeviceTransferCommand extends smithyClient.Command
+class RejectInputDeviceTransferCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "RejectInputDeviceTransfer", {})
     .n("MediaLiveClient", "RejectInputDeviceTransferCommand")
@@ -1218,11 +1216,11 @@ class RejectInputDeviceTransferCommand extends smithyClient.Command
     .build() {
 }
 
-class RestartChannelPipelinesCommand extends smithyClient.Command
+class RestartChannelPipelinesCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "RestartChannelPipelines", {})
     .n("MediaLiveClient", "RestartChannelPipelinesCommand")
@@ -1230,11 +1228,11 @@ class RestartChannelPipelinesCommand extends smithyClient.Command
     .build() {
 }
 
-class StartChannelCommand extends smithyClient.Command
+class StartChannelCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "StartChannel", {})
     .n("MediaLiveClient", "StartChannelCommand")
@@ -1242,11 +1240,11 @@ class StartChannelCommand extends smithyClient.Command
     .build() {
 }
 
-class StartDeleteMonitorDeploymentCommand extends smithyClient.Command
+class StartDeleteMonitorDeploymentCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "StartDeleteMonitorDeployment", {})
     .n("MediaLiveClient", "StartDeleteMonitorDeploymentCommand")
@@ -1254,11 +1252,11 @@ class StartDeleteMonitorDeploymentCommand extends smithyClient.Command
     .build() {
 }
 
-class StartInputDeviceCommand extends smithyClient.Command
+class StartInputDeviceCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "StartInputDevice", {})
     .n("MediaLiveClient", "StartInputDeviceCommand")
@@ -1266,11 +1264,11 @@ class StartInputDeviceCommand extends smithyClient.Command
     .build() {
 }
 
-class StartInputDeviceMaintenanceWindowCommand extends smithyClient.Command
+class StartInputDeviceMaintenanceWindowCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "StartInputDeviceMaintenanceWindow", {})
     .n("MediaLiveClient", "StartInputDeviceMaintenanceWindowCommand")
@@ -1278,11 +1276,11 @@ class StartInputDeviceMaintenanceWindowCommand extends smithyClient.Command
     .build() {
 }
 
-class StartMonitorDeploymentCommand extends smithyClient.Command
+class StartMonitorDeploymentCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "StartMonitorDeployment", {})
     .n("MediaLiveClient", "StartMonitorDeploymentCommand")
@@ -1290,11 +1288,11 @@ class StartMonitorDeploymentCommand extends smithyClient.Command
     .build() {
 }
 
-class StartMultiplexCommand extends smithyClient.Command
+class StartMultiplexCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "StartMultiplex", {})
     .n("MediaLiveClient", "StartMultiplexCommand")
@@ -1302,11 +1300,11 @@ class StartMultiplexCommand extends smithyClient.Command
     .build() {
 }
 
-class StartUpdateSignalMapCommand extends smithyClient.Command
+class StartUpdateSignalMapCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "StartUpdateSignalMap", {})
     .n("MediaLiveClient", "StartUpdateSignalMapCommand")
@@ -1314,11 +1312,11 @@ class StartUpdateSignalMapCommand extends smithyClient.Command
     .build() {
 }
 
-class StopChannelCommand extends smithyClient.Command
+class StopChannelCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "StopChannel", {})
     .n("MediaLiveClient", "StopChannelCommand")
@@ -1326,11 +1324,11 @@ class StopChannelCommand extends smithyClient.Command
     .build() {
 }
 
-class StopInputDeviceCommand extends smithyClient.Command
+class StopInputDeviceCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "StopInputDevice", {})
     .n("MediaLiveClient", "StopInputDeviceCommand")
@@ -1338,11 +1336,11 @@ class StopInputDeviceCommand extends smithyClient.Command
     .build() {
 }
 
-class StopMultiplexCommand extends smithyClient.Command
+class StopMultiplexCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "StopMultiplex", {})
     .n("MediaLiveClient", "StopMultiplexCommand")
@@ -1350,11 +1348,11 @@ class StopMultiplexCommand extends smithyClient.Command
     .build() {
 }
 
-class TransferInputDeviceCommand extends smithyClient.Command
+class TransferInputDeviceCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "TransferInputDevice", {})
     .n("MediaLiveClient", "TransferInputDeviceCommand")
@@ -1362,11 +1360,11 @@ class TransferInputDeviceCommand extends smithyClient.Command
     .build() {
 }
 
-class UpdateAccountConfigurationCommand extends smithyClient.Command
+class UpdateAccountConfigurationCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "UpdateAccountConfiguration", {})
     .n("MediaLiveClient", "UpdateAccountConfigurationCommand")
@@ -1374,11 +1372,11 @@ class UpdateAccountConfigurationCommand extends smithyClient.Command
     .build() {
 }
 
-class UpdateChannelClassCommand extends smithyClient.Command
+class UpdateChannelClassCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "UpdateChannelClass", {})
     .n("MediaLiveClient", "UpdateChannelClassCommand")
@@ -1386,11 +1384,11 @@ class UpdateChannelClassCommand extends smithyClient.Command
     .build() {
 }
 
-class UpdateChannelCommand extends smithyClient.Command
+class UpdateChannelCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "UpdateChannel", {})
     .n("MediaLiveClient", "UpdateChannelCommand")
@@ -1398,11 +1396,11 @@ class UpdateChannelCommand extends smithyClient.Command
     .build() {
 }
 
-class UpdateChannelPlacementGroupCommand extends smithyClient.Command
+class UpdateChannelPlacementGroupCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "UpdateChannelPlacementGroup", {})
     .n("MediaLiveClient", "UpdateChannelPlacementGroupCommand")
@@ -1410,11 +1408,11 @@ class UpdateChannelPlacementGroupCommand extends smithyClient.Command
     .build() {
 }
 
-class UpdateCloudWatchAlarmTemplateCommand extends smithyClient.Command
+class UpdateCloudWatchAlarmTemplateCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "UpdateCloudWatchAlarmTemplate", {})
     .n("MediaLiveClient", "UpdateCloudWatchAlarmTemplateCommand")
@@ -1422,11 +1420,11 @@ class UpdateCloudWatchAlarmTemplateCommand extends smithyClient.Command
     .build() {
 }
 
-class UpdateCloudWatchAlarmTemplateGroupCommand extends smithyClient.Command
+class UpdateCloudWatchAlarmTemplateGroupCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "UpdateCloudWatchAlarmTemplateGroup", {})
     .n("MediaLiveClient", "UpdateCloudWatchAlarmTemplateGroupCommand")
@@ -1434,11 +1432,11 @@ class UpdateCloudWatchAlarmTemplateGroupCommand extends smithyClient.Command
     .build() {
 }
 
-class UpdateClusterCommand extends smithyClient.Command
+class UpdateClusterCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "UpdateCluster", {})
     .n("MediaLiveClient", "UpdateClusterCommand")
@@ -1446,11 +1444,11 @@ class UpdateClusterCommand extends smithyClient.Command
     .build() {
 }
 
-class UpdateEventBridgeRuleTemplateCommand extends smithyClient.Command
+class UpdateEventBridgeRuleTemplateCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "UpdateEventBridgeRuleTemplate", {})
     .n("MediaLiveClient", "UpdateEventBridgeRuleTemplateCommand")
@@ -1458,11 +1456,11 @@ class UpdateEventBridgeRuleTemplateCommand extends smithyClient.Command
     .build() {
 }
 
-class UpdateEventBridgeRuleTemplateGroupCommand extends smithyClient.Command
+class UpdateEventBridgeRuleTemplateGroupCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "UpdateEventBridgeRuleTemplateGroup", {})
     .n("MediaLiveClient", "UpdateEventBridgeRuleTemplateGroupCommand")
@@ -1470,11 +1468,11 @@ class UpdateEventBridgeRuleTemplateGroupCommand extends smithyClient.Command
     .build() {
 }
 
-class UpdateInputCommand extends smithyClient.Command
+class UpdateInputCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "UpdateInput", {})
     .n("MediaLiveClient", "UpdateInputCommand")
@@ -1482,11 +1480,11 @@ class UpdateInputCommand extends smithyClient.Command
     .build() {
 }
 
-class UpdateInputDeviceCommand extends smithyClient.Command
+class UpdateInputDeviceCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "UpdateInputDevice", {})
     .n("MediaLiveClient", "UpdateInputDeviceCommand")
@@ -1494,11 +1492,11 @@ class UpdateInputDeviceCommand extends smithyClient.Command
     .build() {
 }
 
-class UpdateInputSecurityGroupCommand extends smithyClient.Command
+class UpdateInputSecurityGroupCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "UpdateInputSecurityGroup", {})
     .n("MediaLiveClient", "UpdateInputSecurityGroupCommand")
@@ -1506,11 +1504,11 @@ class UpdateInputSecurityGroupCommand extends smithyClient.Command
     .build() {
 }
 
-class UpdateMultiplexCommand extends smithyClient.Command
+class UpdateMultiplexCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "UpdateMultiplex", {})
     .n("MediaLiveClient", "UpdateMultiplexCommand")
@@ -1518,11 +1516,11 @@ class UpdateMultiplexCommand extends smithyClient.Command
     .build() {
 }
 
-class UpdateMultiplexProgramCommand extends smithyClient.Command
+class UpdateMultiplexProgramCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "UpdateMultiplexProgram", {})
     .n("MediaLiveClient", "UpdateMultiplexProgramCommand")
@@ -1530,11 +1528,11 @@ class UpdateMultiplexProgramCommand extends smithyClient.Command
     .build() {
 }
 
-class UpdateNetworkCommand extends smithyClient.Command
+class UpdateNetworkCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "UpdateNetwork", {})
     .n("MediaLiveClient", "UpdateNetworkCommand")
@@ -1542,11 +1540,11 @@ class UpdateNetworkCommand extends smithyClient.Command
     .build() {
 }
 
-class UpdateNodeCommand extends smithyClient.Command
+class UpdateNodeCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "UpdateNode", {})
     .n("MediaLiveClient", "UpdateNodeCommand")
@@ -1554,11 +1552,11 @@ class UpdateNodeCommand extends smithyClient.Command
     .build() {
 }
 
-class UpdateNodeStateCommand extends smithyClient.Command
+class UpdateNodeStateCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "UpdateNodeState", {})
     .n("MediaLiveClient", "UpdateNodeStateCommand")
@@ -1566,11 +1564,11 @@ class UpdateNodeStateCommand extends smithyClient.Command
     .build() {
 }
 
-class UpdateReservationCommand extends smithyClient.Command
+class UpdateReservationCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "UpdateReservation", {})
     .n("MediaLiveClient", "UpdateReservationCommand")
@@ -1578,11 +1576,11 @@ class UpdateReservationCommand extends smithyClient.Command
     .build() {
 }
 
-class UpdateSdiSourceCommand extends smithyClient.Command
+class UpdateSdiSourceCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("MediaLive", "UpdateSdiSource", {})
     .n("MediaLiveClient", "UpdateSdiSourceCommand")
@@ -1636,17 +1634,17 @@ const paginateListSdiSources = core.createPaginator(MediaLiveClient, ListSdiSour
 
 const paginateListSignalMaps = core.createPaginator(MediaLiveClient, ListSignalMapsCommand, "NextToken", "NextToken", "MaxResults");
 
-const checkState$l = async (client, input) => {
+const checkState$l = async (client$1, input) => {
     let reason;
     try {
-        let result = await client.send(new DescribeChannelCommand(input));
+        let result = await client$1.send(new DescribeChannelCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.State;
             };
             if (returnComparator() === "IDLE") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1655,7 +1653,7 @@ const checkState$l = async (client, input) => {
                 return result.State;
             };
             if (returnComparator() === "CREATING") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -1664,7 +1662,7 @@ const checkState$l = async (client, input) => {
                 return result.State;
             };
             if (returnComparator() === "CREATE_FAILED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -1672,32 +1670,32 @@ const checkState$l = async (client, input) => {
     catch (exception) {
         reason = exception;
         if (exception.name === "InternalServerErrorException") {
-            return { state: utilWaiter.WaiterState.RETRY, reason };
+            return { state: client.WaiterState.RETRY, reason };
         }
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForChannelCreated = async (params, input) => {
     const serviceDefaults = { minDelay: 3, maxDelay: 120 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$l);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$l);
 };
 const waitUntilChannelCreated = async (params, input) => {
     const serviceDefaults = { minDelay: 3, maxDelay: 120 };
-    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$l);
-    return utilWaiter.checkExceptions(result);
+    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$l);
+    return client.checkExceptions(result);
 };
 
-const checkState$k = async (client, input) => {
+const checkState$k = async (client$1, input) => {
     let reason;
     try {
-        let result = await client.send(new DescribeChannelCommand(input));
+        let result = await client$1.send(new DescribeChannelCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.State;
             };
             if (returnComparator() === "DELETED") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1706,7 +1704,7 @@ const checkState$k = async (client, input) => {
                 return result.State;
             };
             if (returnComparator() === "DELETING") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -1714,32 +1712,32 @@ const checkState$k = async (client, input) => {
     catch (exception) {
         reason = exception;
         if (exception.name === "InternalServerErrorException") {
-            return { state: utilWaiter.WaiterState.RETRY, reason };
+            return { state: client.WaiterState.RETRY, reason };
         }
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForChannelDeleted = async (params, input) => {
     const serviceDefaults = { minDelay: 5, maxDelay: 120 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$k);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$k);
 };
 const waitUntilChannelDeleted = async (params, input) => {
     const serviceDefaults = { minDelay: 5, maxDelay: 120 };
-    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$k);
-    return utilWaiter.checkExceptions(result);
+    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$k);
+    return client.checkExceptions(result);
 };
 
-const checkState$j = async (client, input) => {
+const checkState$j = async (client$1, input) => {
     let reason;
     try {
-        let result = await client.send(new DescribeChannelPlacementGroupCommand(input));
+        let result = await client$1.send(new DescribeChannelPlacementGroupCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.State;
             };
             if (returnComparator() === "ASSIGNED") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1748,7 +1746,7 @@ const checkState$j = async (client, input) => {
                 return result.State;
             };
             if (returnComparator() === "ASSIGNING") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -1756,32 +1754,32 @@ const checkState$j = async (client, input) => {
     catch (exception) {
         reason = exception;
         if (exception.name === "InternalServerErrorException") {
-            return { state: utilWaiter.WaiterState.RETRY, reason };
+            return { state: client.WaiterState.RETRY, reason };
         }
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForChannelPlacementGroupAssigned = async (params, input) => {
     const serviceDefaults = { minDelay: 3, maxDelay: 120 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$j);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$j);
 };
 const waitUntilChannelPlacementGroupAssigned = async (params, input) => {
     const serviceDefaults = { minDelay: 3, maxDelay: 120 };
-    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$j);
-    return utilWaiter.checkExceptions(result);
+    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$j);
+    return client.checkExceptions(result);
 };
 
-const checkState$i = async (client, input) => {
+const checkState$i = async (client$1, input) => {
     let reason;
     try {
-        let result = await client.send(new DescribeChannelPlacementGroupCommand(input));
+        let result = await client$1.send(new DescribeChannelPlacementGroupCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.State;
             };
             if (returnComparator() === "DELETED") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1790,7 +1788,7 @@ const checkState$i = async (client, input) => {
                 return result.State;
             };
             if (returnComparator() === "DELETING") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -1798,32 +1796,32 @@ const checkState$i = async (client, input) => {
     catch (exception) {
         reason = exception;
         if (exception.name === "InternalServerErrorException") {
-            return { state: utilWaiter.WaiterState.RETRY, reason };
+            return { state: client.WaiterState.RETRY, reason };
         }
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForChannelPlacementGroupDeleted = async (params, input) => {
     const serviceDefaults = { minDelay: 5, maxDelay: 120 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$i);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$i);
 };
 const waitUntilChannelPlacementGroupDeleted = async (params, input) => {
     const serviceDefaults = { minDelay: 5, maxDelay: 120 };
-    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$i);
-    return utilWaiter.checkExceptions(result);
+    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$i);
+    return client.checkExceptions(result);
 };
 
-const checkState$h = async (client, input) => {
+const checkState$h = async (client$1, input) => {
     let reason;
     try {
-        let result = await client.send(new DescribeChannelPlacementGroupCommand(input));
+        let result = await client$1.send(new DescribeChannelPlacementGroupCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.State;
             };
             if (returnComparator() === "UNASSIGNED") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1832,7 +1830,7 @@ const checkState$h = async (client, input) => {
                 return result.State;
             };
             if (returnComparator() === "UNASSIGNING") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -1840,32 +1838,32 @@ const checkState$h = async (client, input) => {
     catch (exception) {
         reason = exception;
         if (exception.name === "InternalServerErrorException") {
-            return { state: utilWaiter.WaiterState.RETRY, reason };
+            return { state: client.WaiterState.RETRY, reason };
         }
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForChannelPlacementGroupUnassigned = async (params, input) => {
     const serviceDefaults = { minDelay: 5, maxDelay: 120 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$h);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$h);
 };
 const waitUntilChannelPlacementGroupUnassigned = async (params, input) => {
     const serviceDefaults = { minDelay: 5, maxDelay: 120 };
-    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$h);
-    return utilWaiter.checkExceptions(result);
+    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$h);
+    return client.checkExceptions(result);
 };
 
-const checkState$g = async (client, input) => {
+const checkState$g = async (client$1, input) => {
     let reason;
     try {
-        let result = await client.send(new DescribeChannelCommand(input));
+        let result = await client$1.send(new DescribeChannelCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.State;
             };
             if (returnComparator() === "RUNNING") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1874,7 +1872,7 @@ const checkState$g = async (client, input) => {
                 return result.State;
             };
             if (returnComparator() === "STARTING") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -1882,32 +1880,32 @@ const checkState$g = async (client, input) => {
     catch (exception) {
         reason = exception;
         if (exception.name === "InternalServerErrorException") {
-            return { state: utilWaiter.WaiterState.RETRY, reason };
+            return { state: client.WaiterState.RETRY, reason };
         }
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForChannelRunning = async (params, input) => {
     const serviceDefaults = { minDelay: 5, maxDelay: 120 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$g);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$g);
 };
 const waitUntilChannelRunning = async (params, input) => {
     const serviceDefaults = { minDelay: 5, maxDelay: 120 };
-    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$g);
-    return utilWaiter.checkExceptions(result);
+    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$g);
+    return client.checkExceptions(result);
 };
 
-const checkState$f = async (client, input) => {
+const checkState$f = async (client$1, input) => {
     let reason;
     try {
-        let result = await client.send(new DescribeChannelCommand(input));
+        let result = await client$1.send(new DescribeChannelCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.State;
             };
             if (returnComparator() === "IDLE") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1916,7 +1914,7 @@ const checkState$f = async (client, input) => {
                 return result.State;
             };
             if (returnComparator() === "STOPPING") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -1924,32 +1922,32 @@ const checkState$f = async (client, input) => {
     catch (exception) {
         reason = exception;
         if (exception.name === "InternalServerErrorException") {
-            return { state: utilWaiter.WaiterState.RETRY, reason };
+            return { state: client.WaiterState.RETRY, reason };
         }
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForChannelStopped = async (params, input) => {
     const serviceDefaults = { minDelay: 5, maxDelay: 120 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$f);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$f);
 };
 const waitUntilChannelStopped = async (params, input) => {
     const serviceDefaults = { minDelay: 5, maxDelay: 120 };
-    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$f);
-    return utilWaiter.checkExceptions(result);
+    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$f);
+    return client.checkExceptions(result);
 };
 
-const checkState$e = async (client, input) => {
+const checkState$e = async (client$1, input) => {
     let reason;
     try {
-        let result = await client.send(new DescribeClusterCommand(input));
+        let result = await client$1.send(new DescribeClusterCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.State;
             };
             if (returnComparator() === "ACTIVE") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1958,7 +1956,7 @@ const checkState$e = async (client, input) => {
                 return result.State;
             };
             if (returnComparator() === "CREATING") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -1967,7 +1965,7 @@ const checkState$e = async (client, input) => {
                 return result.State;
             };
             if (returnComparator() === "CREATE_FAILED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -1975,32 +1973,32 @@ const checkState$e = async (client, input) => {
     catch (exception) {
         reason = exception;
         if (exception.name === "InternalServerErrorException") {
-            return { state: utilWaiter.WaiterState.RETRY, reason };
+            return { state: client.WaiterState.RETRY, reason };
         }
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForClusterCreated = async (params, input) => {
     const serviceDefaults = { minDelay: 3, maxDelay: 120 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$e);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$e);
 };
 const waitUntilClusterCreated = async (params, input) => {
     const serviceDefaults = { minDelay: 3, maxDelay: 120 };
-    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$e);
-    return utilWaiter.checkExceptions(result);
+    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$e);
+    return client.checkExceptions(result);
 };
 
-const checkState$d = async (client, input) => {
+const checkState$d = async (client$1, input) => {
     let reason;
     try {
-        let result = await client.send(new DescribeClusterCommand(input));
+        let result = await client$1.send(new DescribeClusterCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.State;
             };
             if (returnComparator() === "DELETED") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -2009,7 +2007,7 @@ const checkState$d = async (client, input) => {
                 return result.State;
             };
             if (returnComparator() === "DELETING") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2017,32 +2015,32 @@ const checkState$d = async (client, input) => {
     catch (exception) {
         reason = exception;
         if (exception.name === "InternalServerErrorException") {
-            return { state: utilWaiter.WaiterState.RETRY, reason };
+            return { state: client.WaiterState.RETRY, reason };
         }
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForClusterDeleted = async (params, input) => {
     const serviceDefaults = { minDelay: 5, maxDelay: 120 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$d);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$d);
 };
 const waitUntilClusterDeleted = async (params, input) => {
     const serviceDefaults = { minDelay: 5, maxDelay: 120 };
-    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$d);
-    return utilWaiter.checkExceptions(result);
+    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$d);
+    return client.checkExceptions(result);
 };
 
-const checkState$c = async (client, input) => {
+const checkState$c = async (client$1, input) => {
     let reason;
     try {
-        let result = await client.send(new DescribeInputCommand(input));
+        let result = await client$1.send(new DescribeInputCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.State;
             };
             if (returnComparator() === "ATTACHED") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -2051,7 +2049,7 @@ const checkState$c = async (client, input) => {
                 return result.State;
             };
             if (returnComparator() === "DETACHED") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2059,32 +2057,32 @@ const checkState$c = async (client, input) => {
     catch (exception) {
         reason = exception;
         if (exception.name === "InternalServerErrorException") {
-            return { state: utilWaiter.WaiterState.RETRY, reason };
+            return { state: client.WaiterState.RETRY, reason };
         }
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForInputAttached = async (params, input) => {
     const serviceDefaults = { minDelay: 5, maxDelay: 120 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$c);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$c);
 };
 const waitUntilInputAttached = async (params, input) => {
     const serviceDefaults = { minDelay: 5, maxDelay: 120 };
-    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$c);
-    return utilWaiter.checkExceptions(result);
+    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$c);
+    return client.checkExceptions(result);
 };
 
-const checkState$b = async (client, input) => {
+const checkState$b = async (client$1, input) => {
     let reason;
     try {
-        let result = await client.send(new DescribeInputCommand(input));
+        let result = await client$1.send(new DescribeInputCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.State;
             };
             if (returnComparator() === "DELETED") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -2093,7 +2091,7 @@ const checkState$b = async (client, input) => {
                 return result.State;
             };
             if (returnComparator() === "DELETING") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2101,32 +2099,32 @@ const checkState$b = async (client, input) => {
     catch (exception) {
         reason = exception;
         if (exception.name === "InternalServerErrorException") {
-            return { state: utilWaiter.WaiterState.RETRY, reason };
+            return { state: client.WaiterState.RETRY, reason };
         }
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForInputDeleted = async (params, input) => {
     const serviceDefaults = { minDelay: 5, maxDelay: 120 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$b);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$b);
 };
 const waitUntilInputDeleted = async (params, input) => {
     const serviceDefaults = { minDelay: 5, maxDelay: 120 };
-    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$b);
-    return utilWaiter.checkExceptions(result);
+    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$b);
+    return client.checkExceptions(result);
 };
 
-const checkState$a = async (client, input) => {
+const checkState$a = async (client$1, input) => {
     let reason;
     try {
-        let result = await client.send(new DescribeInputCommand(input));
+        let result = await client$1.send(new DescribeInputCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.State;
             };
             if (returnComparator() === "DETACHED") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -2135,7 +2133,7 @@ const checkState$a = async (client, input) => {
                 return result.State;
             };
             if (returnComparator() === "CREATING") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2144,7 +2142,7 @@ const checkState$a = async (client, input) => {
                 return result.State;
             };
             if (returnComparator() === "ATTACHED") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2152,32 +2150,32 @@ const checkState$a = async (client, input) => {
     catch (exception) {
         reason = exception;
         if (exception.name === "InternalServerErrorException") {
-            return { state: utilWaiter.WaiterState.RETRY, reason };
+            return { state: client.WaiterState.RETRY, reason };
         }
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForInputDetached = async (params, input) => {
     const serviceDefaults = { minDelay: 5, maxDelay: 120 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$a);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$a);
 };
 const waitUntilInputDetached = async (params, input) => {
     const serviceDefaults = { minDelay: 5, maxDelay: 120 };
-    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$a);
-    return utilWaiter.checkExceptions(result);
+    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$a);
+    return client.checkExceptions(result);
 };
 
-const checkState$9 = async (client, input) => {
+const checkState$9 = async (client$1, input) => {
     let reason;
     try {
-        let result = await client.send(new DescribeMultiplexCommand(input));
+        let result = await client$1.send(new DescribeMultiplexCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.State;
             };
             if (returnComparator() === "IDLE") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -2186,7 +2184,7 @@ const checkState$9 = async (client, input) => {
                 return result.State;
             };
             if (returnComparator() === "CREATING") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2195,7 +2193,7 @@ const checkState$9 = async (client, input) => {
                 return result.State;
             };
             if (returnComparator() === "CREATE_FAILED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -2203,32 +2201,32 @@ const checkState$9 = async (client, input) => {
     catch (exception) {
         reason = exception;
         if (exception.name === "InternalServerErrorException") {
-            return { state: utilWaiter.WaiterState.RETRY, reason };
+            return { state: client.WaiterState.RETRY, reason };
         }
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForMultiplexCreated = async (params, input) => {
     const serviceDefaults = { minDelay: 3, maxDelay: 120 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$9);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$9);
 };
 const waitUntilMultiplexCreated = async (params, input) => {
     const serviceDefaults = { minDelay: 3, maxDelay: 120 };
-    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$9);
-    return utilWaiter.checkExceptions(result);
+    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$9);
+    return client.checkExceptions(result);
 };
 
-const checkState$8 = async (client, input) => {
+const checkState$8 = async (client$1, input) => {
     let reason;
     try {
-        let result = await client.send(new DescribeMultiplexCommand(input));
+        let result = await client$1.send(new DescribeMultiplexCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.State;
             };
             if (returnComparator() === "DELETED") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -2237,7 +2235,7 @@ const checkState$8 = async (client, input) => {
                 return result.State;
             };
             if (returnComparator() === "DELETING") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2245,32 +2243,32 @@ const checkState$8 = async (client, input) => {
     catch (exception) {
         reason = exception;
         if (exception.name === "InternalServerErrorException") {
-            return { state: utilWaiter.WaiterState.RETRY, reason };
+            return { state: client.WaiterState.RETRY, reason };
         }
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForMultiplexDeleted = async (params, input) => {
     const serviceDefaults = { minDelay: 5, maxDelay: 120 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$8);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$8);
 };
 const waitUntilMultiplexDeleted = async (params, input) => {
     const serviceDefaults = { minDelay: 5, maxDelay: 120 };
-    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$8);
-    return utilWaiter.checkExceptions(result);
+    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$8);
+    return client.checkExceptions(result);
 };
 
-const checkState$7 = async (client, input) => {
+const checkState$7 = async (client$1, input) => {
     let reason;
     try {
-        let result = await client.send(new DescribeMultiplexCommand(input));
+        let result = await client$1.send(new DescribeMultiplexCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.State;
             };
             if (returnComparator() === "RUNNING") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -2279,7 +2277,7 @@ const checkState$7 = async (client, input) => {
                 return result.State;
             };
             if (returnComparator() === "STARTING") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2287,32 +2285,32 @@ const checkState$7 = async (client, input) => {
     catch (exception) {
         reason = exception;
         if (exception.name === "InternalServerErrorException") {
-            return { state: utilWaiter.WaiterState.RETRY, reason };
+            return { state: client.WaiterState.RETRY, reason };
         }
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForMultiplexRunning = async (params, input) => {
     const serviceDefaults = { minDelay: 5, maxDelay: 120 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$7);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$7);
 };
 const waitUntilMultiplexRunning = async (params, input) => {
     const serviceDefaults = { minDelay: 5, maxDelay: 120 };
-    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$7);
-    return utilWaiter.checkExceptions(result);
+    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$7);
+    return client.checkExceptions(result);
 };
 
-const checkState$6 = async (client, input) => {
+const checkState$6 = async (client$1, input) => {
     let reason;
     try {
-        let result = await client.send(new DescribeMultiplexCommand(input));
+        let result = await client$1.send(new DescribeMultiplexCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.State;
             };
             if (returnComparator() === "IDLE") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -2321,7 +2319,7 @@ const checkState$6 = async (client, input) => {
                 return result.State;
             };
             if (returnComparator() === "STOPPING") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2329,32 +2327,32 @@ const checkState$6 = async (client, input) => {
     catch (exception) {
         reason = exception;
         if (exception.name === "InternalServerErrorException") {
-            return { state: utilWaiter.WaiterState.RETRY, reason };
+            return { state: client.WaiterState.RETRY, reason };
         }
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForMultiplexStopped = async (params, input) => {
     const serviceDefaults = { minDelay: 5, maxDelay: 120 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$6);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$6);
 };
 const waitUntilMultiplexStopped = async (params, input) => {
     const serviceDefaults = { minDelay: 5, maxDelay: 120 };
-    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$6);
-    return utilWaiter.checkExceptions(result);
+    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$6);
+    return client.checkExceptions(result);
 };
 
-const checkState$5 = async (client, input) => {
+const checkState$5 = async (client$1, input) => {
     let reason;
     try {
-        let result = await client.send(new DescribeNodeCommand(input));
+        let result = await client$1.send(new DescribeNodeCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.State;
             };
             if (returnComparator() === "DEREGISTERED") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -2363,7 +2361,7 @@ const checkState$5 = async (client, input) => {
                 return result.State;
             };
             if (returnComparator() === "DEREGISTERING") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2372,7 +2370,7 @@ const checkState$5 = async (client, input) => {
                 return result.State;
             };
             if (returnComparator() === "DRAINING") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2380,32 +2378,32 @@ const checkState$5 = async (client, input) => {
     catch (exception) {
         reason = exception;
         if (exception.name === "InternalServerErrorException") {
-            return { state: utilWaiter.WaiterState.RETRY, reason };
+            return { state: client.WaiterState.RETRY, reason };
         }
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForNodeDeregistered = async (params, input) => {
     const serviceDefaults = { minDelay: 5, maxDelay: 120 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$5);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$5);
 };
 const waitUntilNodeDeregistered = async (params, input) => {
     const serviceDefaults = { minDelay: 5, maxDelay: 120 };
-    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$5);
-    return utilWaiter.checkExceptions(result);
+    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$5);
+    return client.checkExceptions(result);
 };
 
-const checkState$4 = async (client, input) => {
+const checkState$4 = async (client$1, input) => {
     let reason;
     try {
-        let result = await client.send(new DescribeNodeCommand(input));
+        let result = await client$1.send(new DescribeNodeCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.State;
             };
             if (returnComparator() === "ACTIVE") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -2414,7 +2412,7 @@ const checkState$4 = async (client, input) => {
                 return result.State;
             };
             if (returnComparator() === "REGISTERING") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2423,7 +2421,7 @@ const checkState$4 = async (client, input) => {
                 return result.State;
             };
             if (returnComparator() === "REGISTRATION_FAILED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -2431,35 +2429,35 @@ const checkState$4 = async (client, input) => {
     catch (exception) {
         reason = exception;
         if (exception.name === "NotFoundException") {
-            return { state: utilWaiter.WaiterState.RETRY, reason };
+            return { state: client.WaiterState.RETRY, reason };
         }
         if (exception.name === "InternalServerErrorException") {
-            return { state: utilWaiter.WaiterState.RETRY, reason };
+            return { state: client.WaiterState.RETRY, reason };
         }
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForNodeRegistered = async (params, input) => {
     const serviceDefaults = { minDelay: 3, maxDelay: 120 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$4);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$4);
 };
 const waitUntilNodeRegistered = async (params, input) => {
     const serviceDefaults = { minDelay: 3, maxDelay: 120 };
-    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$4);
-    return utilWaiter.checkExceptions(result);
+    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$4);
+    return client.checkExceptions(result);
 };
 
-const checkState$3 = async (client, input) => {
+const checkState$3 = async (client$1, input) => {
     let reason;
     try {
-        let result = await client.send(new GetSignalMapCommand(input));
+        let result = await client$1.send(new GetSignalMapCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.Status;
             };
             if (returnComparator() === "CREATE_COMPLETE") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -2468,7 +2466,7 @@ const checkState$3 = async (client, input) => {
                 return result.Status;
             };
             if (returnComparator() === "CREATE_IN_PROGRESS") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2477,7 +2475,7 @@ const checkState$3 = async (client, input) => {
                 return result.Status;
             };
             if (returnComparator() === "CREATE_FAILED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -2485,29 +2483,29 @@ const checkState$3 = async (client, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForSignalMapCreated = async (params, input) => {
     const serviceDefaults = { minDelay: 5, maxDelay: 120 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
 };
 const waitUntilSignalMapCreated = async (params, input) => {
     const serviceDefaults = { minDelay: 5, maxDelay: 120 };
-    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
-    return utilWaiter.checkExceptions(result);
+    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
+    return client.checkExceptions(result);
 };
 
-const checkState$2 = async (client, input) => {
+const checkState$2 = async (client$1, input) => {
     let reason;
     try {
-        let result = await client.send(new GetSignalMapCommand(input));
+        let result = await client$1.send(new GetSignalMapCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.MonitorDeployment.Status;
             };
             if (returnComparator() === "DELETE_COMPLETE") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -2516,7 +2514,7 @@ const checkState$2 = async (client, input) => {
                 return result.MonitorDeployment.Status;
             };
             if (returnComparator() === "DELETE_IN_PROGRESS") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2525,7 +2523,7 @@ const checkState$2 = async (client, input) => {
                 return result.MonitorDeployment.Status;
             };
             if (returnComparator() === "DELETE_FAILED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -2533,29 +2531,29 @@ const checkState$2 = async (client, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForSignalMapMonitorDeleted = async (params, input) => {
     const serviceDefaults = { minDelay: 5, maxDelay: 120 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
 };
 const waitUntilSignalMapMonitorDeleted = async (params, input) => {
     const serviceDefaults = { minDelay: 5, maxDelay: 120 };
-    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
-    return utilWaiter.checkExceptions(result);
+    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
+    return client.checkExceptions(result);
 };
 
-const checkState$1 = async (client, input) => {
+const checkState$1 = async (client$1, input) => {
     let reason;
     try {
-        let result = await client.send(new GetSignalMapCommand(input));
+        let result = await client$1.send(new GetSignalMapCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.MonitorDeployment.Status;
             };
             if (returnComparator() === "DRY_RUN_DEPLOYMENT_COMPLETE") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -2564,7 +2562,7 @@ const checkState$1 = async (client, input) => {
                 return result.MonitorDeployment.Status;
             };
             if (returnComparator() === "DEPLOYMENT_COMPLETE") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -2573,7 +2571,7 @@ const checkState$1 = async (client, input) => {
                 return result.MonitorDeployment.Status;
             };
             if (returnComparator() === "DRY_RUN_DEPLOYMENT_IN_PROGRESS") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2582,7 +2580,7 @@ const checkState$1 = async (client, input) => {
                 return result.MonitorDeployment.Status;
             };
             if (returnComparator() === "DEPLOYMENT_IN_PROGRESS") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2591,7 +2589,7 @@ const checkState$1 = async (client, input) => {
                 return result.MonitorDeployment.Status;
             };
             if (returnComparator() === "DRY_RUN_DEPLOYMENT_FAILED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -2600,7 +2598,7 @@ const checkState$1 = async (client, input) => {
                 return result.MonitorDeployment.Status;
             };
             if (returnComparator() === "DEPLOYMENT_FAILED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -2608,29 +2606,29 @@ const checkState$1 = async (client, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForSignalMapMonitorDeployed = async (params, input) => {
     const serviceDefaults = { minDelay: 5, maxDelay: 120 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
 };
 const waitUntilSignalMapMonitorDeployed = async (params, input) => {
     const serviceDefaults = { minDelay: 5, maxDelay: 120 };
-    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
-    return utilWaiter.checkExceptions(result);
+    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
+    return client.checkExceptions(result);
 };
 
-const checkState = async (client, input) => {
+const checkState = async (client$1, input) => {
     let reason;
     try {
-        let result = await client.send(new GetSignalMapCommand(input));
+        let result = await client$1.send(new GetSignalMapCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.Status;
             };
             if (returnComparator() === "UPDATE_COMPLETE") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -2639,7 +2637,7 @@ const checkState = async (client, input) => {
                 return result.Status;
             };
             if (returnComparator() === "UPDATE_IN_PROGRESS") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2648,7 +2646,7 @@ const checkState = async (client, input) => {
                 return result.Status;
             };
             if (returnComparator() === "UPDATE_FAILED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -2657,7 +2655,7 @@ const checkState = async (client, input) => {
                 return result.Status;
             };
             if (returnComparator() === "UPDATE_REVERTED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -2665,16 +2663,16 @@ const checkState = async (client, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForSignalMapUpdated = async (params, input) => {
     const serviceDefaults = { minDelay: 5, maxDelay: 120 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
 const waitUntilSignalMapUpdated = async (params, input) => {
     const serviceDefaults = { minDelay: 5, maxDelay: 120 };
-    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState);
-    return utilWaiter.checkExceptions(result);
+    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return client.checkExceptions(result);
 };
 
 const commands = {
@@ -2853,7 +2851,7 @@ const waiters = {
 };
 class MediaLive extends MediaLiveClient {
 }
-smithyClient.createAggregatedClient(commands, MediaLive, { paginators, waiters });
+client.createAggregatedClient(commands, MediaLive, { paginators, waiters });
 
 const DashRoleAudio = {
     ALTERNATE: "ALTERNATE",
@@ -4607,8 +4605,8 @@ const UpdateNodeStateShape = {
     DRAINING: "DRAINING",
 };
 
-exports.$Command = smithyClient.Command;
-exports.__Client = smithyClient.Client;
+exports.$Command = client.Command;
+exports.__Client = client.Client;
 exports.MediaLiveServiceException = MediaLiveServiceException.MediaLiveServiceException;
 exports.AacCodingMode = AacCodingMode;
 exports.AacInputType = AacInputType;