@aws-sdk/client-omics 3.1045.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 OmicsServiceException = require('./models/OmicsServiceException');
 
@@ -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 OmicsClient extends smithyClient.Client {
+class OmicsClient extends client.Client {
     config;
     constructor(...[configuration]) {
         const _config_0 = runtimeConfig.getRuntimeConfig(configuration || {});
@@ -87,17 +85,17 @@ class OmicsClient 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 OmicsClient extends smithyClient.Client {
     }
 }
 
-class AbortMultipartReadSetUploadCommand extends smithyClient.Command
+class AbortMultipartReadSetUploadCommand 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("Omics", "AbortMultipartReadSetUpload", {})
     .n("OmicsClient", "AbortMultipartReadSetUploadCommand")
@@ -126,11 +124,11 @@ class AbortMultipartReadSetUploadCommand extends smithyClient.Command
     .build() {
 }
 
-class AcceptShareCommand extends smithyClient.Command
+class AcceptShareCommand 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("Omics", "AcceptShare", {})
     .n("OmicsClient", "AcceptShareCommand")
@@ -138,11 +136,11 @@ class AcceptShareCommand extends smithyClient.Command
     .build() {
 }
 
-class BatchDeleteReadSetCommand extends smithyClient.Command
+class BatchDeleteReadSetCommand 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("Omics", "BatchDeleteReadSet", {})
     .n("OmicsClient", "BatchDeleteReadSetCommand")
@@ -150,11 +148,11 @@ class BatchDeleteReadSetCommand extends smithyClient.Command
     .build() {
 }
 
-class CancelAnnotationImportJobCommand extends smithyClient.Command
+class CancelAnnotationImportJobCommand 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("Omics", "CancelAnnotationImportJob", {})
     .n("OmicsClient", "CancelAnnotationImportJobCommand")
@@ -162,11 +160,11 @@ class CancelAnnotationImportJobCommand extends smithyClient.Command
     .build() {
 }
 
-class CancelRunBatchCommand extends smithyClient.Command
+class CancelRunBatchCommand 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("Omics", "CancelRunBatch", {})
     .n("OmicsClient", "CancelRunBatchCommand")
@@ -174,11 +172,11 @@ class CancelRunBatchCommand extends smithyClient.Command
     .build() {
 }
 
-class CancelRunCommand extends smithyClient.Command
+class CancelRunCommand 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("Omics", "CancelRun", {})
     .n("OmicsClient", "CancelRunCommand")
@@ -186,11 +184,11 @@ class CancelRunCommand extends smithyClient.Command
     .build() {
 }
 
-class CancelVariantImportJobCommand extends smithyClient.Command
+class CancelVariantImportJobCommand 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("Omics", "CancelVariantImportJob", {})
     .n("OmicsClient", "CancelVariantImportJobCommand")
@@ -198,11 +196,11 @@ class CancelVariantImportJobCommand extends smithyClient.Command
     .build() {
 }
 
-class CompleteMultipartReadSetUploadCommand extends smithyClient.Command
+class CompleteMultipartReadSetUploadCommand 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("Omics", "CompleteMultipartReadSetUpload", {})
     .n("OmicsClient", "CompleteMultipartReadSetUploadCommand")
@@ -210,11 +208,11 @@ class CompleteMultipartReadSetUploadCommand extends smithyClient.Command
     .build() {
 }
 
-class CreateAnnotationStoreCommand extends smithyClient.Command
+class CreateAnnotationStoreCommand 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("Omics", "CreateAnnotationStore", {})
     .n("OmicsClient", "CreateAnnotationStoreCommand")
@@ -222,11 +220,11 @@ class CreateAnnotationStoreCommand extends smithyClient.Command
     .build() {
 }
 
-class CreateAnnotationStoreVersionCommand extends smithyClient.Command
+class CreateAnnotationStoreVersionCommand 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("Omics", "CreateAnnotationStoreVersion", {})
     .n("OmicsClient", "CreateAnnotationStoreVersionCommand")
@@ -234,11 +232,11 @@ class CreateAnnotationStoreVersionCommand extends smithyClient.Command
     .build() {
 }
 
-class CreateConfigurationCommand extends smithyClient.Command
+class CreateConfigurationCommand 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("Omics", "CreateConfiguration", {})
     .n("OmicsClient", "CreateConfigurationCommand")
@@ -246,11 +244,11 @@ class CreateConfigurationCommand extends smithyClient.Command
     .build() {
 }
 
-class CreateMultipartReadSetUploadCommand extends smithyClient.Command
+class CreateMultipartReadSetUploadCommand 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("Omics", "CreateMultipartReadSetUpload", {})
     .n("OmicsClient", "CreateMultipartReadSetUploadCommand")
@@ -258,11 +256,11 @@ class CreateMultipartReadSetUploadCommand extends smithyClient.Command
     .build() {
 }
 
-class CreateReferenceStoreCommand extends smithyClient.Command
+class CreateReferenceStoreCommand 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("Omics", "CreateReferenceStore", {})
     .n("OmicsClient", "CreateReferenceStoreCommand")
@@ -270,11 +268,11 @@ class CreateReferenceStoreCommand extends smithyClient.Command
     .build() {
 }
 
-class CreateRunCacheCommand extends smithyClient.Command
+class CreateRunCacheCommand 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("Omics", "CreateRunCache", {})
     .n("OmicsClient", "CreateRunCacheCommand")
@@ -282,11 +280,11 @@ class CreateRunCacheCommand extends smithyClient.Command
     .build() {
 }
 
-class CreateRunGroupCommand extends smithyClient.Command
+class CreateRunGroupCommand 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("Omics", "CreateRunGroup", {})
     .n("OmicsClient", "CreateRunGroupCommand")
@@ -294,11 +292,11 @@ class CreateRunGroupCommand extends smithyClient.Command
     .build() {
 }
 
-class CreateSequenceStoreCommand extends smithyClient.Command
+class CreateSequenceStoreCommand 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("Omics", "CreateSequenceStore", {})
     .n("OmicsClient", "CreateSequenceStoreCommand")
@@ -306,11 +304,11 @@ class CreateSequenceStoreCommand extends smithyClient.Command
     .build() {
 }
 
-class CreateShareCommand extends smithyClient.Command
+class CreateShareCommand 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("Omics", "CreateShare", {})
     .n("OmicsClient", "CreateShareCommand")
@@ -318,11 +316,11 @@ class CreateShareCommand extends smithyClient.Command
     .build() {
 }
 
-class CreateVariantStoreCommand extends smithyClient.Command
+class CreateVariantStoreCommand 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("Omics", "CreateVariantStore", {})
     .n("OmicsClient", "CreateVariantStoreCommand")
@@ -330,11 +328,11 @@ class CreateVariantStoreCommand extends smithyClient.Command
     .build() {
 }
 
-class CreateWorkflowCommand extends smithyClient.Command
+class CreateWorkflowCommand 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("Omics", "CreateWorkflow", {})
     .n("OmicsClient", "CreateWorkflowCommand")
@@ -342,11 +340,11 @@ class CreateWorkflowCommand extends smithyClient.Command
     .build() {
 }
 
-class CreateWorkflowVersionCommand extends smithyClient.Command
+class CreateWorkflowVersionCommand 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("Omics", "CreateWorkflowVersion", {})
     .n("OmicsClient", "CreateWorkflowVersionCommand")
@@ -354,11 +352,11 @@ class CreateWorkflowVersionCommand extends smithyClient.Command
     .build() {
 }
 
-class DeleteAnnotationStoreCommand extends smithyClient.Command
+class DeleteAnnotationStoreCommand 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("Omics", "DeleteAnnotationStore", {})
     .n("OmicsClient", "DeleteAnnotationStoreCommand")
@@ -366,11 +364,11 @@ class DeleteAnnotationStoreCommand extends smithyClient.Command
     .build() {
 }
 
-class DeleteAnnotationStoreVersionsCommand extends smithyClient.Command
+class DeleteAnnotationStoreVersionsCommand 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("Omics", "DeleteAnnotationStoreVersions", {})
     .n("OmicsClient", "DeleteAnnotationStoreVersionsCommand")
@@ -378,11 +376,11 @@ class DeleteAnnotationStoreVersionsCommand extends smithyClient.Command
     .build() {
 }
 
-class DeleteBatchCommand extends smithyClient.Command
+class DeleteBatchCommand 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("Omics", "DeleteBatch", {})
     .n("OmicsClient", "DeleteBatchCommand")
@@ -390,11 +388,11 @@ class DeleteBatchCommand extends smithyClient.Command
     .build() {
 }
 
-class DeleteConfigurationCommand extends smithyClient.Command
+class DeleteConfigurationCommand 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("Omics", "DeleteConfiguration", {})
     .n("OmicsClient", "DeleteConfigurationCommand")
@@ -402,11 +400,11 @@ class DeleteConfigurationCommand extends smithyClient.Command
     .build() {
 }
 
-class DeleteReferenceCommand extends smithyClient.Command
+class DeleteReferenceCommand 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("Omics", "DeleteReference", {})
     .n("OmicsClient", "DeleteReferenceCommand")
@@ -414,11 +412,11 @@ class DeleteReferenceCommand extends smithyClient.Command
     .build() {
 }
 
-class DeleteReferenceStoreCommand extends smithyClient.Command
+class DeleteReferenceStoreCommand 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("Omics", "DeleteReferenceStore", {})
     .n("OmicsClient", "DeleteReferenceStoreCommand")
@@ -426,11 +424,11 @@ class DeleteReferenceStoreCommand extends smithyClient.Command
     .build() {
 }
 
-class DeleteRunBatchCommand extends smithyClient.Command
+class DeleteRunBatchCommand 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("Omics", "DeleteRunBatch", {})
     .n("OmicsClient", "DeleteRunBatchCommand")
@@ -438,11 +436,11 @@ class DeleteRunBatchCommand extends smithyClient.Command
     .build() {
 }
 
-class DeleteRunCacheCommand extends smithyClient.Command
+class DeleteRunCacheCommand 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("Omics", "DeleteRunCache", {})
     .n("OmicsClient", "DeleteRunCacheCommand")
@@ -450,11 +448,11 @@ class DeleteRunCacheCommand extends smithyClient.Command
     .build() {
 }
 
-class DeleteRunCommand extends smithyClient.Command
+class DeleteRunCommand 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("Omics", "DeleteRun", {})
     .n("OmicsClient", "DeleteRunCommand")
@@ -462,11 +460,11 @@ class DeleteRunCommand extends smithyClient.Command
     .build() {
 }
 
-class DeleteRunGroupCommand extends smithyClient.Command
+class DeleteRunGroupCommand 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("Omics", "DeleteRunGroup", {})
     .n("OmicsClient", "DeleteRunGroupCommand")
@@ -474,11 +472,11 @@ class DeleteRunGroupCommand extends smithyClient.Command
     .build() {
 }
 
-class DeleteS3AccessPolicyCommand extends smithyClient.Command
+class DeleteS3AccessPolicyCommand 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("Omics", "DeleteS3AccessPolicy", {})
     .n("OmicsClient", "DeleteS3AccessPolicyCommand")
@@ -486,11 +484,11 @@ class DeleteS3AccessPolicyCommand extends smithyClient.Command
     .build() {
 }
 
-class DeleteSequenceStoreCommand extends smithyClient.Command
+class DeleteSequenceStoreCommand 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("Omics", "DeleteSequenceStore", {})
     .n("OmicsClient", "DeleteSequenceStoreCommand")
@@ -498,11 +496,11 @@ class DeleteSequenceStoreCommand extends smithyClient.Command
     .build() {
 }
 
-class DeleteShareCommand extends smithyClient.Command
+class DeleteShareCommand 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("Omics", "DeleteShare", {})
     .n("OmicsClient", "DeleteShareCommand")
@@ -510,11 +508,11 @@ class DeleteShareCommand extends smithyClient.Command
     .build() {
 }
 
-class DeleteVariantStoreCommand extends smithyClient.Command
+class DeleteVariantStoreCommand 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("Omics", "DeleteVariantStore", {})
     .n("OmicsClient", "DeleteVariantStoreCommand")
@@ -522,11 +520,11 @@ class DeleteVariantStoreCommand extends smithyClient.Command
     .build() {
 }
 
-class DeleteWorkflowCommand extends smithyClient.Command
+class DeleteWorkflowCommand 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("Omics", "DeleteWorkflow", {})
     .n("OmicsClient", "DeleteWorkflowCommand")
@@ -534,11 +532,11 @@ class DeleteWorkflowCommand extends smithyClient.Command
     .build() {
 }
 
-class DeleteWorkflowVersionCommand extends smithyClient.Command
+class DeleteWorkflowVersionCommand 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("Omics", "DeleteWorkflowVersion", {})
     .n("OmicsClient", "DeleteWorkflowVersionCommand")
@@ -546,11 +544,11 @@ class DeleteWorkflowVersionCommand extends smithyClient.Command
     .build() {
 }
 
-class GetAnnotationImportJobCommand extends smithyClient.Command
+class GetAnnotationImportJobCommand 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("Omics", "GetAnnotationImportJob", {})
     .n("OmicsClient", "GetAnnotationImportJobCommand")
@@ -558,11 +556,11 @@ class GetAnnotationImportJobCommand extends smithyClient.Command
     .build() {
 }
 
-class GetAnnotationStoreCommand extends smithyClient.Command
+class GetAnnotationStoreCommand 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("Omics", "GetAnnotationStore", {})
     .n("OmicsClient", "GetAnnotationStoreCommand")
@@ -570,11 +568,11 @@ class GetAnnotationStoreCommand extends smithyClient.Command
     .build() {
 }
 
-class GetAnnotationStoreVersionCommand extends smithyClient.Command
+class GetAnnotationStoreVersionCommand 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("Omics", "GetAnnotationStoreVersion", {})
     .n("OmicsClient", "GetAnnotationStoreVersionCommand")
@@ -582,11 +580,11 @@ class GetAnnotationStoreVersionCommand extends smithyClient.Command
     .build() {
 }
 
-class GetBatchCommand extends smithyClient.Command
+class GetBatchCommand 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("Omics", "GetBatch", {})
     .n("OmicsClient", "GetBatchCommand")
@@ -594,11 +592,11 @@ class GetBatchCommand extends smithyClient.Command
     .build() {
 }
 
-class GetConfigurationCommand extends smithyClient.Command
+class GetConfigurationCommand 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("Omics", "GetConfiguration", {})
     .n("OmicsClient", "GetConfigurationCommand")
@@ -606,11 +604,11 @@ class GetConfigurationCommand extends smithyClient.Command
     .build() {
 }
 
-class GetReadSetActivationJobCommand extends smithyClient.Command
+class GetReadSetActivationJobCommand 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("Omics", "GetReadSetActivationJob", {})
     .n("OmicsClient", "GetReadSetActivationJobCommand")
@@ -618,11 +616,11 @@ class GetReadSetActivationJobCommand extends smithyClient.Command
     .build() {
 }
 
-class GetReadSetCommand extends smithyClient.Command
+class GetReadSetCommand 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("Omics", "GetReadSet", {})
     .n("OmicsClient", "GetReadSetCommand")
@@ -630,11 +628,11 @@ class GetReadSetCommand extends smithyClient.Command
     .build() {
 }
 
-class GetReadSetExportJobCommand extends smithyClient.Command
+class GetReadSetExportJobCommand 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("Omics", "GetReadSetExportJob", {})
     .n("OmicsClient", "GetReadSetExportJobCommand")
@@ -642,11 +640,11 @@ class GetReadSetExportJobCommand extends smithyClient.Command
     .build() {
 }
 
-class GetReadSetImportJobCommand extends smithyClient.Command
+class GetReadSetImportJobCommand 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("Omics", "GetReadSetImportJob", {})
     .n("OmicsClient", "GetReadSetImportJobCommand")
@@ -654,11 +652,11 @@ class GetReadSetImportJobCommand extends smithyClient.Command
     .build() {
 }
 
-class GetReadSetMetadataCommand extends smithyClient.Command
+class GetReadSetMetadataCommand 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("Omics", "GetReadSetMetadata", {})
     .n("OmicsClient", "GetReadSetMetadataCommand")
@@ -666,11 +664,11 @@ class GetReadSetMetadataCommand extends smithyClient.Command
     .build() {
 }
 
-class GetReferenceCommand extends smithyClient.Command
+class GetReferenceCommand 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("Omics", "GetReference", {})
     .n("OmicsClient", "GetReferenceCommand")
@@ -678,11 +676,11 @@ class GetReferenceCommand extends smithyClient.Command
     .build() {
 }
 
-class GetReferenceImportJobCommand extends smithyClient.Command
+class GetReferenceImportJobCommand 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("Omics", "GetReferenceImportJob", {})
     .n("OmicsClient", "GetReferenceImportJobCommand")
@@ -690,11 +688,11 @@ class GetReferenceImportJobCommand extends smithyClient.Command
     .build() {
 }
 
-class GetReferenceMetadataCommand extends smithyClient.Command
+class GetReferenceMetadataCommand 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("Omics", "GetReferenceMetadata", {})
     .n("OmicsClient", "GetReferenceMetadataCommand")
@@ -702,11 +700,11 @@ class GetReferenceMetadataCommand extends smithyClient.Command
     .build() {
 }
 
-class GetReferenceStoreCommand extends smithyClient.Command
+class GetReferenceStoreCommand 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("Omics", "GetReferenceStore", {})
     .n("OmicsClient", "GetReferenceStoreCommand")
@@ -714,11 +712,11 @@ class GetReferenceStoreCommand extends smithyClient.Command
     .build() {
 }
 
-class GetRunCacheCommand extends smithyClient.Command
+class GetRunCacheCommand 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("Omics", "GetRunCache", {})
     .n("OmicsClient", "GetRunCacheCommand")
@@ -726,11 +724,11 @@ class GetRunCacheCommand extends smithyClient.Command
     .build() {
 }
 
-class GetRunCommand extends smithyClient.Command
+class GetRunCommand 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("Omics", "GetRun", {})
     .n("OmicsClient", "GetRunCommand")
@@ -738,11 +736,11 @@ class GetRunCommand extends smithyClient.Command
     .build() {
 }
 
-class GetRunGroupCommand extends smithyClient.Command
+class GetRunGroupCommand 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("Omics", "GetRunGroup", {})
     .n("OmicsClient", "GetRunGroupCommand")
@@ -750,11 +748,11 @@ class GetRunGroupCommand extends smithyClient.Command
     .build() {
 }
 
-class GetRunTaskCommand extends smithyClient.Command
+class GetRunTaskCommand 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("Omics", "GetRunTask", {})
     .n("OmicsClient", "GetRunTaskCommand")
@@ -762,11 +760,11 @@ class GetRunTaskCommand extends smithyClient.Command
     .build() {
 }
 
-class GetS3AccessPolicyCommand extends smithyClient.Command
+class GetS3AccessPolicyCommand 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("Omics", "GetS3AccessPolicy", {})
     .n("OmicsClient", "GetS3AccessPolicyCommand")
@@ -774,11 +772,11 @@ class GetS3AccessPolicyCommand extends smithyClient.Command
     .build() {
 }
 
-class GetSequenceStoreCommand extends smithyClient.Command
+class GetSequenceStoreCommand 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("Omics", "GetSequenceStore", {})
     .n("OmicsClient", "GetSequenceStoreCommand")
@@ -786,11 +784,11 @@ class GetSequenceStoreCommand extends smithyClient.Command
     .build() {
 }
 
-class GetShareCommand extends smithyClient.Command
+class GetShareCommand 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("Omics", "GetShare", {})
     .n("OmicsClient", "GetShareCommand")
@@ -798,11 +796,11 @@ class GetShareCommand extends smithyClient.Command
     .build() {
 }
 
-class GetVariantImportJobCommand extends smithyClient.Command
+class GetVariantImportJobCommand 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("Omics", "GetVariantImportJob", {})
     .n("OmicsClient", "GetVariantImportJobCommand")
@@ -810,11 +808,11 @@ class GetVariantImportJobCommand extends smithyClient.Command
     .build() {
 }
 
-class GetVariantStoreCommand extends smithyClient.Command
+class GetVariantStoreCommand 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("Omics", "GetVariantStore", {})
     .n("OmicsClient", "GetVariantStoreCommand")
@@ -822,11 +820,11 @@ class GetVariantStoreCommand extends smithyClient.Command
     .build() {
 }
 
-class GetWorkflowCommand extends smithyClient.Command
+class GetWorkflowCommand 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("Omics", "GetWorkflow", {})
     .n("OmicsClient", "GetWorkflowCommand")
@@ -834,11 +832,11 @@ class GetWorkflowCommand extends smithyClient.Command
     .build() {
 }
 
-class GetWorkflowVersionCommand extends smithyClient.Command
+class GetWorkflowVersionCommand 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("Omics", "GetWorkflowVersion", {})
     .n("OmicsClient", "GetWorkflowVersionCommand")
@@ -846,11 +844,11 @@ class GetWorkflowVersionCommand extends smithyClient.Command
     .build() {
 }
 
-class ListAnnotationImportJobsCommand extends smithyClient.Command
+class ListAnnotationImportJobsCommand 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("Omics", "ListAnnotationImportJobs", {})
     .n("OmicsClient", "ListAnnotationImportJobsCommand")
@@ -858,11 +856,11 @@ class ListAnnotationImportJobsCommand extends smithyClient.Command
     .build() {
 }
 
-class ListAnnotationStoresCommand extends smithyClient.Command
+class ListAnnotationStoresCommand 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("Omics", "ListAnnotationStores", {})
     .n("OmicsClient", "ListAnnotationStoresCommand")
@@ -870,11 +868,11 @@ class ListAnnotationStoresCommand extends smithyClient.Command
     .build() {
 }
 
-class ListAnnotationStoreVersionsCommand extends smithyClient.Command
+class ListAnnotationStoreVersionsCommand 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("Omics", "ListAnnotationStoreVersions", {})
     .n("OmicsClient", "ListAnnotationStoreVersionsCommand")
@@ -882,11 +880,11 @@ class ListAnnotationStoreVersionsCommand extends smithyClient.Command
     .build() {
 }
 
-class ListBatchCommand extends smithyClient.Command
+class ListBatchCommand 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("Omics", "ListBatch", {})
     .n("OmicsClient", "ListBatchCommand")
@@ -894,11 +892,11 @@ class ListBatchCommand extends smithyClient.Command
     .build() {
 }
 
-class ListConfigurationsCommand extends smithyClient.Command
+class ListConfigurationsCommand 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("Omics", "ListConfigurations", {})
     .n("OmicsClient", "ListConfigurationsCommand")
@@ -906,11 +904,11 @@ class ListConfigurationsCommand extends smithyClient.Command
     .build() {
 }
 
-class ListMultipartReadSetUploadsCommand extends smithyClient.Command
+class ListMultipartReadSetUploadsCommand 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("Omics", "ListMultipartReadSetUploads", {})
     .n("OmicsClient", "ListMultipartReadSetUploadsCommand")
@@ -918,11 +916,11 @@ class ListMultipartReadSetUploadsCommand extends smithyClient.Command
     .build() {
 }
 
-class ListReadSetActivationJobsCommand extends smithyClient.Command
+class ListReadSetActivationJobsCommand 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("Omics", "ListReadSetActivationJobs", {})
     .n("OmicsClient", "ListReadSetActivationJobsCommand")
@@ -930,11 +928,11 @@ class ListReadSetActivationJobsCommand extends smithyClient.Command
     .build() {
 }
 
-class ListReadSetExportJobsCommand extends smithyClient.Command
+class ListReadSetExportJobsCommand 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("Omics", "ListReadSetExportJobs", {})
     .n("OmicsClient", "ListReadSetExportJobsCommand")
@@ -942,11 +940,11 @@ class ListReadSetExportJobsCommand extends smithyClient.Command
     .build() {
 }
 
-class ListReadSetImportJobsCommand extends smithyClient.Command
+class ListReadSetImportJobsCommand 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("Omics", "ListReadSetImportJobs", {})
     .n("OmicsClient", "ListReadSetImportJobsCommand")
@@ -954,11 +952,11 @@ class ListReadSetImportJobsCommand extends smithyClient.Command
     .build() {
 }
 
-class ListReadSetsCommand extends smithyClient.Command
+class ListReadSetsCommand 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("Omics", "ListReadSets", {})
     .n("OmicsClient", "ListReadSetsCommand")
@@ -966,11 +964,11 @@ class ListReadSetsCommand extends smithyClient.Command
     .build() {
 }
 
-class ListReadSetUploadPartsCommand extends smithyClient.Command
+class ListReadSetUploadPartsCommand 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("Omics", "ListReadSetUploadParts", {})
     .n("OmicsClient", "ListReadSetUploadPartsCommand")
@@ -978,11 +976,11 @@ class ListReadSetUploadPartsCommand extends smithyClient.Command
     .build() {
 }
 
-class ListReferenceImportJobsCommand extends smithyClient.Command
+class ListReferenceImportJobsCommand 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("Omics", "ListReferenceImportJobs", {})
     .n("OmicsClient", "ListReferenceImportJobsCommand")
@@ -990,11 +988,11 @@ class ListReferenceImportJobsCommand extends smithyClient.Command
     .build() {
 }
 
-class ListReferencesCommand extends smithyClient.Command
+class ListReferencesCommand 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("Omics", "ListReferences", {})
     .n("OmicsClient", "ListReferencesCommand")
@@ -1002,11 +1000,11 @@ class ListReferencesCommand extends smithyClient.Command
     .build() {
 }
 
-class ListReferenceStoresCommand extends smithyClient.Command
+class ListReferenceStoresCommand 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("Omics", "ListReferenceStores", {})
     .n("OmicsClient", "ListReferenceStoresCommand")
@@ -1014,11 +1012,11 @@ class ListReferenceStoresCommand extends smithyClient.Command
     .build() {
 }
 
-class ListRunCachesCommand extends smithyClient.Command
+class ListRunCachesCommand 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("Omics", "ListRunCaches", {})
     .n("OmicsClient", "ListRunCachesCommand")
@@ -1026,11 +1024,11 @@ class ListRunCachesCommand extends smithyClient.Command
     .build() {
 }
 
-class ListRunGroupsCommand extends smithyClient.Command
+class ListRunGroupsCommand 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("Omics", "ListRunGroups", {})
     .n("OmicsClient", "ListRunGroupsCommand")
@@ -1038,11 +1036,11 @@ class ListRunGroupsCommand extends smithyClient.Command
     .build() {
 }
 
-class ListRunsCommand extends smithyClient.Command
+class ListRunsCommand 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("Omics", "ListRuns", {})
     .n("OmicsClient", "ListRunsCommand")
@@ -1050,11 +1048,11 @@ class ListRunsCommand extends smithyClient.Command
     .build() {
 }
 
-class ListRunsInBatchCommand extends smithyClient.Command
+class ListRunsInBatchCommand 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("Omics", "ListRunsInBatch", {})
     .n("OmicsClient", "ListRunsInBatchCommand")
@@ -1062,11 +1060,11 @@ class ListRunsInBatchCommand extends smithyClient.Command
     .build() {
 }
 
-class ListRunTasksCommand extends smithyClient.Command
+class ListRunTasksCommand 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("Omics", "ListRunTasks", {})
     .n("OmicsClient", "ListRunTasksCommand")
@@ -1074,11 +1072,11 @@ class ListRunTasksCommand extends smithyClient.Command
     .build() {
 }
 
-class ListSequenceStoresCommand extends smithyClient.Command
+class ListSequenceStoresCommand 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("Omics", "ListSequenceStores", {})
     .n("OmicsClient", "ListSequenceStoresCommand")
@@ -1086,11 +1084,11 @@ class ListSequenceStoresCommand extends smithyClient.Command
     .build() {
 }
 
-class ListSharesCommand extends smithyClient.Command
+class ListSharesCommand 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("Omics", "ListShares", {})
     .n("OmicsClient", "ListSharesCommand")
@@ -1098,11 +1096,11 @@ class ListSharesCommand 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("Omics", "ListTagsForResource", {})
     .n("OmicsClient", "ListTagsForResourceCommand")
@@ -1110,11 +1108,11 @@ class ListTagsForResourceCommand extends smithyClient.Command
     .build() {
 }
 
-class ListVariantImportJobsCommand extends smithyClient.Command
+class ListVariantImportJobsCommand 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("Omics", "ListVariantImportJobs", {})
     .n("OmicsClient", "ListVariantImportJobsCommand")
@@ -1122,11 +1120,11 @@ class ListVariantImportJobsCommand extends smithyClient.Command
     .build() {
 }
 
-class ListVariantStoresCommand extends smithyClient.Command
+class ListVariantStoresCommand 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("Omics", "ListVariantStores", {})
     .n("OmicsClient", "ListVariantStoresCommand")
@@ -1134,11 +1132,11 @@ class ListVariantStoresCommand extends smithyClient.Command
     .build() {
 }
 
-class ListWorkflowsCommand extends smithyClient.Command
+class ListWorkflowsCommand 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("Omics", "ListWorkflows", {})
     .n("OmicsClient", "ListWorkflowsCommand")
@@ -1146,11 +1144,11 @@ class ListWorkflowsCommand extends smithyClient.Command
     .build() {
 }
 
-class ListWorkflowVersionsCommand extends smithyClient.Command
+class ListWorkflowVersionsCommand 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("Omics", "ListWorkflowVersions", {})
     .n("OmicsClient", "ListWorkflowVersionsCommand")
@@ -1158,11 +1156,11 @@ class ListWorkflowVersionsCommand extends smithyClient.Command
     .build() {
 }
 
-class PutS3AccessPolicyCommand extends smithyClient.Command
+class PutS3AccessPolicyCommand 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("Omics", "PutS3AccessPolicy", {})
     .n("OmicsClient", "PutS3AccessPolicyCommand")
@@ -1170,11 +1168,11 @@ class PutS3AccessPolicyCommand extends smithyClient.Command
     .build() {
 }
 
-class StartAnnotationImportJobCommand extends smithyClient.Command
+class StartAnnotationImportJobCommand 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("Omics", "StartAnnotationImportJob", {})
     .n("OmicsClient", "StartAnnotationImportJobCommand")
@@ -1182,11 +1180,11 @@ class StartAnnotationImportJobCommand extends smithyClient.Command
     .build() {
 }
 
-class StartReadSetActivationJobCommand extends smithyClient.Command
+class StartReadSetActivationJobCommand 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("Omics", "StartReadSetActivationJob", {})
     .n("OmicsClient", "StartReadSetActivationJobCommand")
@@ -1194,11 +1192,11 @@ class StartReadSetActivationJobCommand extends smithyClient.Command
     .build() {
 }
 
-class StartReadSetExportJobCommand extends smithyClient.Command
+class StartReadSetExportJobCommand 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("Omics", "StartReadSetExportJob", {})
     .n("OmicsClient", "StartReadSetExportJobCommand")
@@ -1206,11 +1204,11 @@ class StartReadSetExportJobCommand extends smithyClient.Command
     .build() {
 }
 
-class StartReadSetImportJobCommand extends smithyClient.Command
+class StartReadSetImportJobCommand 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("Omics", "StartReadSetImportJob", {})
     .n("OmicsClient", "StartReadSetImportJobCommand")
@@ -1218,11 +1216,11 @@ class StartReadSetImportJobCommand extends smithyClient.Command
     .build() {
 }
 
-class StartReferenceImportJobCommand extends smithyClient.Command
+class StartReferenceImportJobCommand 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("Omics", "StartReferenceImportJob", {})
     .n("OmicsClient", "StartReferenceImportJobCommand")
@@ -1230,11 +1228,11 @@ class StartReferenceImportJobCommand extends smithyClient.Command
     .build() {
 }
 
-class StartRunBatchCommand extends smithyClient.Command
+class StartRunBatchCommand 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("Omics", "StartRunBatch", {})
     .n("OmicsClient", "StartRunBatchCommand")
@@ -1242,11 +1240,11 @@ class StartRunBatchCommand extends smithyClient.Command
     .build() {
 }
 
-class StartRunCommand extends smithyClient.Command
+class StartRunCommand 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("Omics", "StartRun", {})
     .n("OmicsClient", "StartRunCommand")
@@ -1254,11 +1252,11 @@ class StartRunCommand extends smithyClient.Command
     .build() {
 }
 
-class StartVariantImportJobCommand extends smithyClient.Command
+class StartVariantImportJobCommand 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("Omics", "StartVariantImportJob", {})
     .n("OmicsClient", "StartVariantImportJobCommand")
@@ -1266,11 +1264,11 @@ class StartVariantImportJobCommand extends smithyClient.Command
     .build() {
 }
 
-class TagResourceCommand extends smithyClient.Command
+class TagResourceCommand 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("Omics", "TagResource", {})
     .n("OmicsClient", "TagResourceCommand")
@@ -1278,11 +1276,11 @@ class TagResourceCommand extends smithyClient.Command
     .build() {
 }
 
-class UntagResourceCommand extends smithyClient.Command
+class UntagResourceCommand 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("Omics", "UntagResource", {})
     .n("OmicsClient", "UntagResourceCommand")
@@ -1290,11 +1288,11 @@ class UntagResourceCommand extends smithyClient.Command
     .build() {
 }
 
-class UpdateAnnotationStoreCommand extends smithyClient.Command
+class UpdateAnnotationStoreCommand 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("Omics", "UpdateAnnotationStore", {})
     .n("OmicsClient", "UpdateAnnotationStoreCommand")
@@ -1302,11 +1300,11 @@ class UpdateAnnotationStoreCommand extends smithyClient.Command
     .build() {
 }
 
-class UpdateAnnotationStoreVersionCommand extends smithyClient.Command
+class UpdateAnnotationStoreVersionCommand 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("Omics", "UpdateAnnotationStoreVersion", {})
     .n("OmicsClient", "UpdateAnnotationStoreVersionCommand")
@@ -1314,11 +1312,11 @@ class UpdateAnnotationStoreVersionCommand extends smithyClient.Command
     .build() {
 }
 
-class UpdateRunCacheCommand extends smithyClient.Command
+class UpdateRunCacheCommand 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("Omics", "UpdateRunCache", {})
     .n("OmicsClient", "UpdateRunCacheCommand")
@@ -1326,11 +1324,11 @@ class UpdateRunCacheCommand extends smithyClient.Command
     .build() {
 }
 
-class UpdateRunGroupCommand extends smithyClient.Command
+class UpdateRunGroupCommand 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("Omics", "UpdateRunGroup", {})
     .n("OmicsClient", "UpdateRunGroupCommand")
@@ -1338,11 +1336,11 @@ class UpdateRunGroupCommand extends smithyClient.Command
     .build() {
 }
 
-class UpdateSequenceStoreCommand extends smithyClient.Command
+class UpdateSequenceStoreCommand 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("Omics", "UpdateSequenceStore", {})
     .n("OmicsClient", "UpdateSequenceStoreCommand")
@@ -1350,11 +1348,11 @@ class UpdateSequenceStoreCommand extends smithyClient.Command
     .build() {
 }
 
-class UpdateVariantStoreCommand extends smithyClient.Command
+class UpdateVariantStoreCommand 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("Omics", "UpdateVariantStore", {})
     .n("OmicsClient", "UpdateVariantStoreCommand")
@@ -1362,11 +1360,11 @@ class UpdateVariantStoreCommand extends smithyClient.Command
     .build() {
 }
 
-class UpdateWorkflowCommand extends smithyClient.Command
+class UpdateWorkflowCommand 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("Omics", "UpdateWorkflow", {})
     .n("OmicsClient", "UpdateWorkflowCommand")
@@ -1374,11 +1372,11 @@ class UpdateWorkflowCommand extends smithyClient.Command
     .build() {
 }
 
-class UpdateWorkflowVersionCommand extends smithyClient.Command
+class UpdateWorkflowVersionCommand 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("Omics", "UpdateWorkflowVersion", {})
     .n("OmicsClient", "UpdateWorkflowVersionCommand")
@@ -1386,11 +1384,11 @@ class UpdateWorkflowVersionCommand extends smithyClient.Command
     .build() {
 }
 
-class UploadReadSetPartCommand extends smithyClient.Command
+class UploadReadSetPartCommand 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("Omics", "UploadReadSetPart", {})
     .n("OmicsClient", "UploadReadSetPartCommand")
@@ -1448,17 +1446,17 @@ const paginateListWorkflows = core.createPaginator(OmicsClient, ListWorkflowsCom
 
 const paginateListWorkflowVersions = core.createPaginator(OmicsClient, ListWorkflowVersionsCommand, "startingToken", "nextToken", "maxResults");
 
-const checkState$h = async (client, input) => {
+const checkState$h = async (client$1, input) => {
     let reason;
     try {
-        let result = await client.send(new GetAnnotationImportJobCommand(input));
+        let result = await client$1.send(new GetAnnotationImportJobCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.status;
             };
             if (returnComparator() === "SUBMITTED") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -1467,7 +1465,7 @@ const checkState$h = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "IN_PROGRESS") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -1476,7 +1474,7 @@ const checkState$h = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "FAILED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -1485,7 +1483,7 @@ const checkState$h = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "CANCELLED") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1494,7 +1492,7 @@ const checkState$h = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "COMPLETED") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1502,29 +1500,29 @@ const checkState$h = async (client, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForAnnotationImportJobCreated = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$h);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$h);
 };
 const waitUntilAnnotationImportJobCreated = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    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 GetAnnotationStoreCommand(input));
+        let result = await client$1.send(new GetAnnotationStoreCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.status;
             };
             if (returnComparator() === "ACTIVE") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1533,7 +1531,7 @@ const checkState$g = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "CREATING") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -1542,7 +1540,7 @@ const checkState$g = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "UPDATING") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -1551,7 +1549,7 @@ const checkState$g = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "FAILED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -1559,29 +1557,29 @@ const checkState$g = async (client, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForAnnotationStoreCreated = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$g);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$g);
 };
 const waitUntilAnnotationStoreCreated = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    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 GetAnnotationStoreCommand(input));
+        let result = await client$1.send(new GetAnnotationStoreCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.status;
             };
             if (returnComparator() === "DELETED") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1590,7 +1588,7 @@ const checkState$f = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "DELETING") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -1598,32 +1596,32 @@ const checkState$f = async (client, input) => {
     catch (exception) {
         reason = exception;
         if (exception.name === "ResourceNotFoundException") {
-            return { state: utilWaiter.WaiterState.SUCCESS, reason };
+            return { state: client.WaiterState.SUCCESS, reason };
         }
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForAnnotationStoreDeleted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$f);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$f);
 };
 const waitUntilAnnotationStoreDeleted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    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 GetAnnotationStoreVersionCommand(input));
+        let result = await client$1.send(new GetAnnotationStoreVersionCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.status;
             };
             if (returnComparator() === "ACTIVE") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1632,7 +1630,7 @@ const checkState$e = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "CREATING") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -1641,7 +1639,7 @@ const checkState$e = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "UPDATING") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -1650,7 +1648,7 @@ const checkState$e = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "FAILED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -1658,29 +1656,29 @@ const checkState$e = async (client, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForAnnotationStoreVersionCreated = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$e);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$e);
 };
 const waitUntilAnnotationStoreVersionCreated = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    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 GetAnnotationStoreVersionCommand(input));
+        let result = await client$1.send(new GetAnnotationStoreVersionCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.status;
             };
             if (returnComparator() === "DELETED") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1689,7 +1687,7 @@ const checkState$d = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "DELETING") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -1697,32 +1695,32 @@ const checkState$d = async (client, input) => {
     catch (exception) {
         reason = exception;
         if (exception.name === "ResourceNotFoundException") {
-            return { state: utilWaiter.WaiterState.SUCCESS, reason };
+            return { state: client.WaiterState.SUCCESS, reason };
         }
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForAnnotationStoreVersionDeleted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$d);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$d);
 };
 const waitUntilAnnotationStoreVersionDeleted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    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 GetReadSetActivationJobCommand(input));
+        let result = await client$1.send(new GetReadSetActivationJobCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.status;
             };
             if (returnComparator() === "COMPLETED") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1731,7 +1729,7 @@ const checkState$c = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "SUBMITTED") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -1740,7 +1738,7 @@ const checkState$c = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "IN_PROGRESS") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -1749,7 +1747,7 @@ const checkState$c = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "CANCELLING") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -1758,7 +1756,7 @@ const checkState$c = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "CANCELLED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -1767,7 +1765,7 @@ const checkState$c = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "FAILED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -1776,7 +1774,7 @@ const checkState$c = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "COMPLETED_WITH_FAILURES") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -1784,29 +1782,29 @@ const checkState$c = async (client, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForReadSetActivationJobCompleted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$c);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$c);
 };
 const waitUntilReadSetActivationJobCompleted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    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 GetReadSetExportJobCommand(input));
+        let result = await client$1.send(new GetReadSetExportJobCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.status;
             };
             if (returnComparator() === "COMPLETED") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1815,7 +1813,7 @@ const checkState$b = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "SUBMITTED") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -1824,7 +1822,7 @@ const checkState$b = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "IN_PROGRESS") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -1833,7 +1831,7 @@ const checkState$b = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "CANCELLING") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -1842,7 +1840,7 @@ const checkState$b = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "CANCELLED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -1851,7 +1849,7 @@ const checkState$b = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "FAILED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -1860,7 +1858,7 @@ const checkState$b = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "COMPLETED_WITH_FAILURES") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -1868,29 +1866,29 @@ const checkState$b = async (client, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForReadSetExportJobCompleted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$b);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$b);
 };
 const waitUntilReadSetExportJobCompleted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    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 GetReadSetImportJobCommand(input));
+        let result = await client$1.send(new GetReadSetImportJobCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.status;
             };
             if (returnComparator() === "COMPLETED") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1899,7 +1897,7 @@ const checkState$a = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "SUBMITTED") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -1908,7 +1906,7 @@ const checkState$a = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "IN_PROGRESS") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -1917,7 +1915,7 @@ const checkState$a = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "CANCELLING") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -1926,7 +1924,7 @@ const checkState$a = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "CANCELLED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -1935,7 +1933,7 @@ const checkState$a = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "FAILED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -1944,7 +1942,7 @@ const checkState$a = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "COMPLETED_WITH_FAILURES") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -1952,29 +1950,29 @@ const checkState$a = async (client, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForReadSetImportJobCompleted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$a);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$a);
 };
 const waitUntilReadSetImportJobCompleted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    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 GetReferenceImportJobCommand(input));
+        let result = await client$1.send(new GetReferenceImportJobCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.status;
             };
             if (returnComparator() === "COMPLETED") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1983,7 +1981,7 @@ const checkState$9 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "SUBMITTED") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -1992,7 +1990,7 @@ const checkState$9 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "IN_PROGRESS") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2001,7 +1999,7 @@ const checkState$9 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "CANCELLING") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2010,7 +2008,7 @@ const checkState$9 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "CANCELLED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -2019,7 +2017,7 @@ const checkState$9 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "FAILED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -2028,7 +2026,7 @@ const checkState$9 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "COMPLETED_WITH_FAILURES") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -2036,29 +2034,29 @@ const checkState$9 = async (client, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForReferenceImportJobCompleted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$9);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$9);
 };
 const waitUntilReferenceImportJobCompleted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    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 GetRunCommand(input));
+        let result = await client$1.send(new GetRunCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.status;
             };
             if (returnComparator() === "COMPLETED") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -2067,7 +2065,7 @@ const checkState$8 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "PENDING") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2076,7 +2074,7 @@ const checkState$8 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "STARTING") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2085,7 +2083,7 @@ const checkState$8 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "RUNNING") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2094,7 +2092,7 @@ const checkState$8 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "STOPPING") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2103,7 +2101,7 @@ const checkState$8 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "FAILED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -2111,29 +2109,29 @@ const checkState$8 = async (client, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForRunCompleted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$8);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$8);
 };
 const waitUntilRunCompleted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    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 GetRunCommand(input));
+        let result = await client$1.send(new GetRunCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.status;
             };
             if (returnComparator() === "RUNNING") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -2142,7 +2140,7 @@ const checkState$7 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "PENDING") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2151,7 +2149,7 @@ const checkState$7 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "STARTING") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2160,7 +2158,7 @@ const checkState$7 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "FAILED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -2169,7 +2167,7 @@ const checkState$7 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "CANCELLED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -2177,29 +2175,29 @@ const checkState$7 = async (client, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForRunRunning = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$7);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$7);
 };
 const waitUntilRunRunning = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    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 GetRunTaskCommand(input));
+        let result = await client$1.send(new GetRunTaskCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.status;
             };
             if (returnComparator() === "COMPLETED") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -2208,7 +2206,7 @@ const checkState$6 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "PENDING") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2217,7 +2215,7 @@ const checkState$6 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "STARTING") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2226,7 +2224,7 @@ const checkState$6 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "RUNNING") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2235,7 +2233,7 @@ const checkState$6 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "STOPPING") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2244,7 +2242,7 @@ const checkState$6 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "FAILED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -2252,29 +2250,29 @@ const checkState$6 = async (client, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForTaskCompleted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$6);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$6);
 };
 const waitUntilTaskCompleted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    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 GetRunTaskCommand(input));
+        let result = await client$1.send(new GetRunTaskCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.status;
             };
             if (returnComparator() === "RUNNING") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -2283,7 +2281,7 @@ const checkState$5 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "PENDING") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2292,7 +2290,7 @@ const checkState$5 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "STARTING") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2301,7 +2299,7 @@ const checkState$5 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "FAILED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -2310,7 +2308,7 @@ const checkState$5 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "CANCELLED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -2318,29 +2316,29 @@ const checkState$5 = async (client, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForTaskRunning = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$5);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$5);
 };
 const waitUntilTaskRunning = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    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 GetVariantImportJobCommand(input));
+        let result = await client$1.send(new GetVariantImportJobCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.status;
             };
             if (returnComparator() === "SUBMITTED") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2349,7 +2347,7 @@ const checkState$4 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "IN_PROGRESS") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2358,7 +2356,7 @@ const checkState$4 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "FAILED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -2367,7 +2365,7 @@ const checkState$4 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "CANCELLED") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -2376,7 +2374,7 @@ const checkState$4 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "COMPLETED") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -2384,29 +2382,29 @@ const checkState$4 = async (client, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForVariantImportJobCreated = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$4);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$4);
 };
 const waitUntilVariantImportJobCreated = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    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 GetVariantStoreCommand(input));
+        let result = await client$1.send(new GetVariantStoreCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.status;
             };
             if (returnComparator() === "ACTIVE") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -2415,7 +2413,7 @@ const checkState$3 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "CREATING") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2424,7 +2422,7 @@ const checkState$3 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "UPDATING") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2433,7 +2431,7 @@ const checkState$3 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "FAILED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -2441,29 +2439,29 @@ const checkState$3 = async (client, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForVariantStoreCreated = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
 };
 const waitUntilVariantStoreCreated = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    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 GetVariantStoreCommand(input));
+        let result = await client$1.send(new GetVariantStoreCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.status;
             };
             if (returnComparator() === "DELETED") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -2472,7 +2470,7 @@ const checkState$2 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "DELETING") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2480,32 +2478,32 @@ const checkState$2 = async (client, input) => {
     catch (exception) {
         reason = exception;
         if (exception.name === "ResourceNotFoundException") {
-            return { state: utilWaiter.WaiterState.SUCCESS, reason };
+            return { state: client.WaiterState.SUCCESS, reason };
         }
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForVariantStoreDeleted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
 };
 const waitUntilVariantStoreDeleted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    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 GetWorkflowCommand(input));
+        let result = await client$1.send(new GetWorkflowCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.status;
             };
             if (returnComparator() === "ACTIVE") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -2514,7 +2512,7 @@ const checkState$1 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "CREATING") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2523,7 +2521,7 @@ const checkState$1 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "UPDATING") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2532,7 +2530,7 @@ const checkState$1 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "FAILED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -2540,29 +2538,29 @@ const checkState$1 = async (client, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForWorkflowActive = async (params, input) => {
     const serviceDefaults = { minDelay: 3, maxDelay: 30 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
 };
 const waitUntilWorkflowActive = async (params, input) => {
     const serviceDefaults = { minDelay: 3, maxDelay: 30 };
-    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 GetWorkflowVersionCommand(input));
+        let result = await client$1.send(new GetWorkflowVersionCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.status;
             };
             if (returnComparator() === "ACTIVE") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -2571,7 +2569,7 @@ const checkState = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "CREATING") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2580,7 +2578,7 @@ const checkState = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "UPDATING") {
-                return { state: utilWaiter.WaiterState.RETRY, reason };
+                return { state: client.WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2589,7 +2587,7 @@ const checkState = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "FAILED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -2597,16 +2595,16 @@ const checkState = async (client, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForWorkflowVersionActive = async (params, input) => {
     const serviceDefaults = { minDelay: 3, maxDelay: 30 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
 const waitUntilWorkflowVersionActive = async (params, input) => {
     const serviceDefaults = { minDelay: 3, maxDelay: 30 };
-    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 = {
@@ -2767,7 +2765,7 @@ const waiters = {
 };
 class Omics extends OmicsClient {
 }
-smithyClient.createAggregatedClient(commands, Omics, { paginators, waiters });
+client.createAggregatedClient(commands, Omics, { paginators, waiters });
 
 const Accelerators = {
     GPU: "GPU",
@@ -3076,8 +3074,8 @@ const ResourceOwner = {
     SELF: "SELF",
 };
 
-exports.$Command = smithyClient.Command;
-exports.__Client = smithyClient.Client;
+exports.$Command = client.Command;
+exports.__Client = client.Client;
 exports.OmicsServiceException = OmicsServiceException.OmicsServiceException;
 exports.AbortMultipartReadSetUploadCommand = AbortMultipartReadSetUploadCommand;
 exports.Accelerators = Accelerators;