@aws-sdk/client-omics 3.1068.0 → 3.1070.0

package/dist-cjs/index.js

@@ -1,18 +1,21 @@
-'use strict';
-
-var client$1 = require('@aws-sdk/core/client');
-var core = require('@smithy/core');
-var client = require('@smithy/core/client');
-var config = require('@smithy/core/config');
-var endpoints = require('@smithy/core/endpoints');
-var protocols = require('@smithy/core/protocols');
-var retry = require('@smithy/core/retry');
-var schema = require('@smithy/core/schema');
-var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
-var runtimeConfig = require('./runtimeConfig');
-var schemas_0 = require('./schemas/schemas_0');
-var errors = require('./models/errors');
-var OmicsServiceException = require('./models/OmicsServiceException');
+var __exportStar = (m, e) => { Object.assign(e, m); };
+const { getAwsRegionExtensionConfiguration, resolveAwsRegionExtensionConfiguration, resolveUserAgentConfig, resolveHostHeaderConfig, getUserAgentPlugin, getHostHeaderPlugin, getLoggerPlugin, getRecursionDetectionPlugin } = require("@aws-sdk/core/client");
+const { getHttpAuthSchemeEndpointRuleSetPlugin, DefaultIdentityProviderConfig, getHttpSigningPlugin, createPaginator } = require("@smithy/core");
+const { getDefaultExtensionConfiguration, resolveDefaultRuntimeConfig, Client, Command, createWaiter, checkExceptions, WaiterState, createAggregatedClient } = require("@smithy/core/client");
+exports.$Command = Command;
+exports.__Client = Client;
+const { resolveRegionConfig } = require("@smithy/core/config");
+const { resolveEndpointConfig, getEndpointPlugin } = require("@smithy/core/endpoints");
+const { getHttpHandlerExtensionConfiguration, resolveHttpHandlerRuntimeConfig, getContentLengthPlugin } = require("@smithy/core/protocols");
+const { resolveRetryConfig, getRetryPlugin } = require("@smithy/core/retry");
+const { getSchemaSerdePlugin } = require("@smithy/core/schema");
+const { resolveHttpAuthSchemeConfig, defaultOmicsHttpAuthSchemeParametersProvider } = require("./auth/httpAuthSchemeProvider");
+const { getRuntimeConfig } = require("./runtimeConfig");
+const { AbortMultipartReadSetUpload$, AcceptShare$, BatchDeleteReadSet$, CancelAnnotationImportJob$, CancelRunBatch$, CancelRun$, CancelVariantImportJob$, CompleteMultipartReadSetUpload$, CreateAnnotationStore$, CreateAnnotationStoreVersion$, CreateConfiguration$, CreateMultipartReadSetUpload$, CreateReferenceStore$, CreateRunCache$, CreateRunGroup$, CreateSequenceStore$, CreateShare$, CreateVariantStore$, CreateWorkflow$, CreateWorkflowVersion$, DeleteAnnotationStore$, DeleteAnnotationStoreVersions$, DeleteBatch$, DeleteConfiguration$, DeleteReference$, DeleteReferenceStore$, DeleteRunBatch$, DeleteRunCache$, DeleteRun$, DeleteRunGroup$, DeleteS3AccessPolicy$, DeleteSequenceStore$, DeleteShare$, DeleteVariantStore$, DeleteWorkflow$, DeleteWorkflowVersion$, GetAnnotationImportJob$, GetAnnotationStore$, GetAnnotationStoreVersion$, GetBatch$, GetConfiguration$, GetReadSetActivationJob$, GetReadSet$, GetReadSetExportJob$, GetReadSetImportJob$, GetReadSetMetadata$, GetReference$, GetReferenceImportJob$, GetReferenceMetadata$, GetReferenceStore$, GetRunCache$, GetRun$, GetRunGroup$, GetRunTask$, GetS3AccessPolicy$, GetSequenceStore$, GetShare$, GetVariantImportJob$, GetVariantStore$, GetWorkflow$, GetWorkflowVersion$, ListAnnotationImportJobs$, ListAnnotationStores$, ListAnnotationStoreVersions$, ListBatch$, ListConfigurations$, ListMultipartReadSetUploads$, ListReadSetActivationJobs$, ListReadSetExportJobs$, ListReadSetImportJobs$, ListReadSets$, ListReadSetUploadParts$, ListReferenceImportJobs$, ListReferences$, ListReferenceStores$, ListRunCaches$, ListRunGroups$, ListRuns$, ListRunsInBatch$, ListRunTasks$, ListSequenceStores$, ListShares$, ListTagsForResource$, ListVariantImportJobs$, ListVariantStores$, ListWorkflows$, ListWorkflowVersions$, PutS3AccessPolicy$, StartAnnotationImportJob$, StartReadSetActivationJob$, StartReadSetExportJob$, StartReadSetImportJob$, StartReferenceImportJob$, StartRunBatch$, StartRun$, StartVariantImportJob$, TagResource$, UntagResource$, UpdateAnnotationStore$, UpdateAnnotationStoreVersion$, UpdateRunCache$, UpdateRunGroup$, UpdateSequenceStore$, UpdateVariantStore$, UpdateWorkflow$, UpdateWorkflowVersion$, UploadReadSetPart$ } = require("./schemas/schemas_0");
+__exportStar(require("./schemas/schemas_0"), exports);
+__exportStar(require("./models/errors"), exports);
+const { OmicsServiceException } = require("./models/OmicsServiceException");
+exports.OmicsServiceException = OmicsServiceException;
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -68,1391 +71,1391 @@ const resolveHttpAuthRuntimeConfig = (config) => {
 };
 
 const resolveRuntimeExtensions = (runtimeConfig, extensions) => {
-    const extensionConfiguration = Object.assign(client$1.getAwsRegionExtensionConfiguration(runtimeConfig), client.getDefaultExtensionConfiguration(runtimeConfig), protocols.getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
+    const extensionConfiguration = Object.assign(getAwsRegionExtensionConfiguration(runtimeConfig), getDefaultExtensionConfiguration(runtimeConfig), getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
     extensions.forEach((extension) => extension.configure(extensionConfiguration));
-    return Object.assign(runtimeConfig, client$1.resolveAwsRegionExtensionConfiguration(extensionConfiguration), client.resolveDefaultRuntimeConfig(extensionConfiguration), protocols.resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
+    return Object.assign(runtimeConfig, resolveAwsRegionExtensionConfiguration(extensionConfiguration), resolveDefaultRuntimeConfig(extensionConfiguration), resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
 };
 
-class OmicsClient extends client.Client {
+class OmicsClient extends Client {
     config;
     constructor(...[configuration]) {
-        const _config_0 = runtimeConfig.getRuntimeConfig(configuration || {});
+        const _config_0 = getRuntimeConfig(configuration || {});
         super(_config_0);
         this.initConfig = _config_0;
         const _config_1 = resolveClientEndpointParameters(_config_0);
-        const _config_2 = client$1.resolveUserAgentConfig(_config_1);
-        const _config_3 = retry.resolveRetryConfig(_config_2);
-        const _config_4 = config.resolveRegionConfig(_config_3);
-        const _config_5 = client$1.resolveHostHeaderConfig(_config_4);
-        const _config_6 = endpoints.resolveEndpointConfig(_config_5);
-        const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
+        const _config_2 = resolveUserAgentConfig(_config_1);
+        const _config_3 = resolveRetryConfig(_config_2);
+        const _config_4 = resolveRegionConfig(_config_3);
+        const _config_5 = resolveHostHeaderConfig(_config_4);
+        const _config_6 = resolveEndpointConfig(_config_5);
+        const _config_7 = 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(client$1.getUserAgentPlugin(this.config));
-        this.middlewareStack.use(retry.getRetryPlugin(this.config));
-        this.middlewareStack.use(protocols.getContentLengthPlugin(this.config));
-        this.middlewareStack.use(client$1.getHostHeaderPlugin(this.config));
-        this.middlewareStack.use(client$1.getLoggerPlugin(this.config));
-        this.middlewareStack.use(client$1.getRecursionDetectionPlugin(this.config));
-        this.middlewareStack.use(core.getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
-            httpAuthSchemeParametersProvider: httpAuthSchemeProvider.defaultOmicsHttpAuthSchemeParametersProvider,
-            identityProviderConfigProvider: async (config) => new core.DefaultIdentityProviderConfig({
+        this.middlewareStack.use(getSchemaSerdePlugin(this.config));
+        this.middlewareStack.use(getUserAgentPlugin(this.config));
+        this.middlewareStack.use(getRetryPlugin(this.config));
+        this.middlewareStack.use(getContentLengthPlugin(this.config));
+        this.middlewareStack.use(getHostHeaderPlugin(this.config));
+        this.middlewareStack.use(getLoggerPlugin(this.config));
+        this.middlewareStack.use(getRecursionDetectionPlugin(this.config));
+        this.middlewareStack.use(getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
+            httpAuthSchemeParametersProvider: defaultOmicsHttpAuthSchemeParametersProvider,
+            identityProviderConfigProvider: async (config) => new DefaultIdentityProviderConfig({
                 "aws.auth#sigv4": config.credentials,
             }),
         }));
-        this.middlewareStack.use(core.getHttpSigningPlugin(this.config));
+        this.middlewareStack.use(getHttpSigningPlugin(this.config));
     }
     destroy() {
         super.destroy();
     }
 }
 
-class AbortMultipartReadSetUploadCommand extends client.Command
+class AbortMultipartReadSetUploadCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "AbortMultipartReadSetUpload", {})
     .n("OmicsClient", "AbortMultipartReadSetUploadCommand")
-    .sc(schemas_0.AbortMultipartReadSetUpload$)
+    .sc(AbortMultipartReadSetUpload$)
     .build() {
 }
 
-class AcceptShareCommand extends client.Command
+class AcceptShareCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "AcceptShare", {})
     .n("OmicsClient", "AcceptShareCommand")
-    .sc(schemas_0.AcceptShare$)
+    .sc(AcceptShare$)
     .build() {
 }
 
-class BatchDeleteReadSetCommand extends client.Command
+class BatchDeleteReadSetCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "BatchDeleteReadSet", {})
     .n("OmicsClient", "BatchDeleteReadSetCommand")
-    .sc(schemas_0.BatchDeleteReadSet$)
+    .sc(BatchDeleteReadSet$)
     .build() {
 }
 
-class CancelAnnotationImportJobCommand extends client.Command
+class CancelAnnotationImportJobCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "CancelAnnotationImportJob", {})
     .n("OmicsClient", "CancelAnnotationImportJobCommand")
-    .sc(schemas_0.CancelAnnotationImportJob$)
+    .sc(CancelAnnotationImportJob$)
     .build() {
 }
 
-class CancelRunBatchCommand extends client.Command
+class CancelRunBatchCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "CancelRunBatch", {})
     .n("OmicsClient", "CancelRunBatchCommand")
-    .sc(schemas_0.CancelRunBatch$)
+    .sc(CancelRunBatch$)
     .build() {
 }
 
-class CancelRunCommand extends client.Command
+class CancelRunCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "CancelRun", {})
     .n("OmicsClient", "CancelRunCommand")
-    .sc(schemas_0.CancelRun$)
+    .sc(CancelRun$)
     .build() {
 }
 
-class CancelVariantImportJobCommand extends client.Command
+class CancelVariantImportJobCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "CancelVariantImportJob", {})
     .n("OmicsClient", "CancelVariantImportJobCommand")
-    .sc(schemas_0.CancelVariantImportJob$)
+    .sc(CancelVariantImportJob$)
     .build() {
 }
 
-class CompleteMultipartReadSetUploadCommand extends client.Command
+class CompleteMultipartReadSetUploadCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "CompleteMultipartReadSetUpload", {})
     .n("OmicsClient", "CompleteMultipartReadSetUploadCommand")
-    .sc(schemas_0.CompleteMultipartReadSetUpload$)
+    .sc(CompleteMultipartReadSetUpload$)
     .build() {
 }
 
-class CreateAnnotationStoreCommand extends client.Command
+class CreateAnnotationStoreCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "CreateAnnotationStore", {})
     .n("OmicsClient", "CreateAnnotationStoreCommand")
-    .sc(schemas_0.CreateAnnotationStore$)
+    .sc(CreateAnnotationStore$)
     .build() {
 }
 
-class CreateAnnotationStoreVersionCommand extends client.Command
+class CreateAnnotationStoreVersionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "CreateAnnotationStoreVersion", {})
     .n("OmicsClient", "CreateAnnotationStoreVersionCommand")
-    .sc(schemas_0.CreateAnnotationStoreVersion$)
+    .sc(CreateAnnotationStoreVersion$)
     .build() {
 }
 
-class CreateConfigurationCommand extends client.Command
+class CreateConfigurationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "CreateConfiguration", {})
     .n("OmicsClient", "CreateConfigurationCommand")
-    .sc(schemas_0.CreateConfiguration$)
+    .sc(CreateConfiguration$)
     .build() {
 }
 
-class CreateMultipartReadSetUploadCommand extends client.Command
+class CreateMultipartReadSetUploadCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "CreateMultipartReadSetUpload", {})
     .n("OmicsClient", "CreateMultipartReadSetUploadCommand")
-    .sc(schemas_0.CreateMultipartReadSetUpload$)
+    .sc(CreateMultipartReadSetUpload$)
     .build() {
 }
 
-class CreateReferenceStoreCommand extends client.Command
+class CreateReferenceStoreCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "CreateReferenceStore", {})
     .n("OmicsClient", "CreateReferenceStoreCommand")
-    .sc(schemas_0.CreateReferenceStore$)
+    .sc(CreateReferenceStore$)
     .build() {
 }
 
-class CreateRunCacheCommand extends client.Command
+class CreateRunCacheCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "CreateRunCache", {})
     .n("OmicsClient", "CreateRunCacheCommand")
-    .sc(schemas_0.CreateRunCache$)
+    .sc(CreateRunCache$)
     .build() {
 }
 
-class CreateRunGroupCommand extends client.Command
+class CreateRunGroupCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "CreateRunGroup", {})
     .n("OmicsClient", "CreateRunGroupCommand")
-    .sc(schemas_0.CreateRunGroup$)
+    .sc(CreateRunGroup$)
     .build() {
 }
 
-class CreateSequenceStoreCommand extends client.Command
+class CreateSequenceStoreCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "CreateSequenceStore", {})
     .n("OmicsClient", "CreateSequenceStoreCommand")
-    .sc(schemas_0.CreateSequenceStore$)
+    .sc(CreateSequenceStore$)
     .build() {
 }
 
-class CreateShareCommand extends client.Command
+class CreateShareCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "CreateShare", {})
     .n("OmicsClient", "CreateShareCommand")
-    .sc(schemas_0.CreateShare$)
+    .sc(CreateShare$)
     .build() {
 }
 
-class CreateVariantStoreCommand extends client.Command
+class CreateVariantStoreCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "CreateVariantStore", {})
     .n("OmicsClient", "CreateVariantStoreCommand")
-    .sc(schemas_0.CreateVariantStore$)
+    .sc(CreateVariantStore$)
     .build() {
 }
 
-class CreateWorkflowCommand extends client.Command
+class CreateWorkflowCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "CreateWorkflow", {})
     .n("OmicsClient", "CreateWorkflowCommand")
-    .sc(schemas_0.CreateWorkflow$)
+    .sc(CreateWorkflow$)
     .build() {
 }
 
-class CreateWorkflowVersionCommand extends client.Command
+class CreateWorkflowVersionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "CreateWorkflowVersion", {})
     .n("OmicsClient", "CreateWorkflowVersionCommand")
-    .sc(schemas_0.CreateWorkflowVersion$)
+    .sc(CreateWorkflowVersion$)
     .build() {
 }
 
-class DeleteAnnotationStoreCommand extends client.Command
+class DeleteAnnotationStoreCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "DeleteAnnotationStore", {})
     .n("OmicsClient", "DeleteAnnotationStoreCommand")
-    .sc(schemas_0.DeleteAnnotationStore$)
+    .sc(DeleteAnnotationStore$)
     .build() {
 }
 
-class DeleteAnnotationStoreVersionsCommand extends client.Command
+class DeleteAnnotationStoreVersionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "DeleteAnnotationStoreVersions", {})
     .n("OmicsClient", "DeleteAnnotationStoreVersionsCommand")
-    .sc(schemas_0.DeleteAnnotationStoreVersions$)
+    .sc(DeleteAnnotationStoreVersions$)
     .build() {
 }
 
-class DeleteBatchCommand extends client.Command
+class DeleteBatchCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "DeleteBatch", {})
     .n("OmicsClient", "DeleteBatchCommand")
-    .sc(schemas_0.DeleteBatch$)
+    .sc(DeleteBatch$)
     .build() {
 }
 
-class DeleteConfigurationCommand extends client.Command
+class DeleteConfigurationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "DeleteConfiguration", {})
     .n("OmicsClient", "DeleteConfigurationCommand")
-    .sc(schemas_0.DeleteConfiguration$)
+    .sc(DeleteConfiguration$)
     .build() {
 }
 
-class DeleteReferenceCommand extends client.Command
+class DeleteReferenceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "DeleteReference", {})
     .n("OmicsClient", "DeleteReferenceCommand")
-    .sc(schemas_0.DeleteReference$)
+    .sc(DeleteReference$)
     .build() {
 }
 
-class DeleteReferenceStoreCommand extends client.Command
+class DeleteReferenceStoreCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "DeleteReferenceStore", {})
     .n("OmicsClient", "DeleteReferenceStoreCommand")
-    .sc(schemas_0.DeleteReferenceStore$)
+    .sc(DeleteReferenceStore$)
     .build() {
 }
 
-class DeleteRunBatchCommand extends client.Command
+class DeleteRunBatchCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "DeleteRunBatch", {})
     .n("OmicsClient", "DeleteRunBatchCommand")
-    .sc(schemas_0.DeleteRunBatch$)
+    .sc(DeleteRunBatch$)
     .build() {
 }
 
-class DeleteRunCacheCommand extends client.Command
+class DeleteRunCacheCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "DeleteRunCache", {})
     .n("OmicsClient", "DeleteRunCacheCommand")
-    .sc(schemas_0.DeleteRunCache$)
+    .sc(DeleteRunCache$)
     .build() {
 }
 
-class DeleteRunCommand extends client.Command
+class DeleteRunCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "DeleteRun", {})
     .n("OmicsClient", "DeleteRunCommand")
-    .sc(schemas_0.DeleteRun$)
+    .sc(DeleteRun$)
     .build() {
 }
 
-class DeleteRunGroupCommand extends client.Command
+class DeleteRunGroupCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "DeleteRunGroup", {})
     .n("OmicsClient", "DeleteRunGroupCommand")
-    .sc(schemas_0.DeleteRunGroup$)
+    .sc(DeleteRunGroup$)
     .build() {
 }
 
-class DeleteS3AccessPolicyCommand extends client.Command
+class DeleteS3AccessPolicyCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "DeleteS3AccessPolicy", {})
     .n("OmicsClient", "DeleteS3AccessPolicyCommand")
-    .sc(schemas_0.DeleteS3AccessPolicy$)
+    .sc(DeleteS3AccessPolicy$)
     .build() {
 }
 
-class DeleteSequenceStoreCommand extends client.Command
+class DeleteSequenceStoreCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "DeleteSequenceStore", {})
     .n("OmicsClient", "DeleteSequenceStoreCommand")
-    .sc(schemas_0.DeleteSequenceStore$)
+    .sc(DeleteSequenceStore$)
     .build() {
 }
 
-class DeleteShareCommand extends client.Command
+class DeleteShareCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "DeleteShare", {})
     .n("OmicsClient", "DeleteShareCommand")
-    .sc(schemas_0.DeleteShare$)
+    .sc(DeleteShare$)
     .build() {
 }
 
-class DeleteVariantStoreCommand extends client.Command
+class DeleteVariantStoreCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "DeleteVariantStore", {})
     .n("OmicsClient", "DeleteVariantStoreCommand")
-    .sc(schemas_0.DeleteVariantStore$)
+    .sc(DeleteVariantStore$)
     .build() {
 }
 
-class DeleteWorkflowCommand extends client.Command
+class DeleteWorkflowCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "DeleteWorkflow", {})
     .n("OmicsClient", "DeleteWorkflowCommand")
-    .sc(schemas_0.DeleteWorkflow$)
+    .sc(DeleteWorkflow$)
     .build() {
 }
 
-class DeleteWorkflowVersionCommand extends client.Command
+class DeleteWorkflowVersionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "DeleteWorkflowVersion", {})
     .n("OmicsClient", "DeleteWorkflowVersionCommand")
-    .sc(schemas_0.DeleteWorkflowVersion$)
+    .sc(DeleteWorkflowVersion$)
     .build() {
 }
 
-class GetAnnotationImportJobCommand extends client.Command
+class GetAnnotationImportJobCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "GetAnnotationImportJob", {})
     .n("OmicsClient", "GetAnnotationImportJobCommand")
-    .sc(schemas_0.GetAnnotationImportJob$)
+    .sc(GetAnnotationImportJob$)
     .build() {
 }
 
-class GetAnnotationStoreCommand extends client.Command
+class GetAnnotationStoreCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "GetAnnotationStore", {})
     .n("OmicsClient", "GetAnnotationStoreCommand")
-    .sc(schemas_0.GetAnnotationStore$)
+    .sc(GetAnnotationStore$)
     .build() {
 }
 
-class GetAnnotationStoreVersionCommand extends client.Command
+class GetAnnotationStoreVersionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "GetAnnotationStoreVersion", {})
     .n("OmicsClient", "GetAnnotationStoreVersionCommand")
-    .sc(schemas_0.GetAnnotationStoreVersion$)
+    .sc(GetAnnotationStoreVersion$)
     .build() {
 }
 
-class GetBatchCommand extends client.Command
+class GetBatchCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "GetBatch", {})
     .n("OmicsClient", "GetBatchCommand")
-    .sc(schemas_0.GetBatch$)
+    .sc(GetBatch$)
     .build() {
 }
 
-class GetConfigurationCommand extends client.Command
+class GetConfigurationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "GetConfiguration", {})
     .n("OmicsClient", "GetConfigurationCommand")
-    .sc(schemas_0.GetConfiguration$)
+    .sc(GetConfiguration$)
     .build() {
 }
 
-class GetReadSetActivationJobCommand extends client.Command
+class GetReadSetActivationJobCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "GetReadSetActivationJob", {})
     .n("OmicsClient", "GetReadSetActivationJobCommand")
-    .sc(schemas_0.GetReadSetActivationJob$)
+    .sc(GetReadSetActivationJob$)
     .build() {
 }
 
-class GetReadSetCommand extends client.Command
+class GetReadSetCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "GetReadSet", {})
     .n("OmicsClient", "GetReadSetCommand")
-    .sc(schemas_0.GetReadSet$)
+    .sc(GetReadSet$)
     .build() {
 }
 
-class GetReadSetExportJobCommand extends client.Command
+class GetReadSetExportJobCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "GetReadSetExportJob", {})
     .n("OmicsClient", "GetReadSetExportJobCommand")
-    .sc(schemas_0.GetReadSetExportJob$)
+    .sc(GetReadSetExportJob$)
     .build() {
 }
 
-class GetReadSetImportJobCommand extends client.Command
+class GetReadSetImportJobCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "GetReadSetImportJob", {})
     .n("OmicsClient", "GetReadSetImportJobCommand")
-    .sc(schemas_0.GetReadSetImportJob$)
+    .sc(GetReadSetImportJob$)
     .build() {
 }
 
-class GetReadSetMetadataCommand extends client.Command
+class GetReadSetMetadataCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "GetReadSetMetadata", {})
     .n("OmicsClient", "GetReadSetMetadataCommand")
-    .sc(schemas_0.GetReadSetMetadata$)
+    .sc(GetReadSetMetadata$)
     .build() {
 }
 
-class GetReferenceCommand extends client.Command
+class GetReferenceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "GetReference", {})
     .n("OmicsClient", "GetReferenceCommand")
-    .sc(schemas_0.GetReference$)
+    .sc(GetReference$)
     .build() {
 }
 
-class GetReferenceImportJobCommand extends client.Command
+class GetReferenceImportJobCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "GetReferenceImportJob", {})
     .n("OmicsClient", "GetReferenceImportJobCommand")
-    .sc(schemas_0.GetReferenceImportJob$)
+    .sc(GetReferenceImportJob$)
     .build() {
 }
 
-class GetReferenceMetadataCommand extends client.Command
+class GetReferenceMetadataCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "GetReferenceMetadata", {})
     .n("OmicsClient", "GetReferenceMetadataCommand")
-    .sc(schemas_0.GetReferenceMetadata$)
+    .sc(GetReferenceMetadata$)
     .build() {
 }
 
-class GetReferenceStoreCommand extends client.Command
+class GetReferenceStoreCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "GetReferenceStore", {})
     .n("OmicsClient", "GetReferenceStoreCommand")
-    .sc(schemas_0.GetReferenceStore$)
+    .sc(GetReferenceStore$)
     .build() {
 }
 
-class GetRunCacheCommand extends client.Command
+class GetRunCacheCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "GetRunCache", {})
     .n("OmicsClient", "GetRunCacheCommand")
-    .sc(schemas_0.GetRunCache$)
+    .sc(GetRunCache$)
     .build() {
 }
 
-class GetRunCommand extends client.Command
+class GetRunCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "GetRun", {})
     .n("OmicsClient", "GetRunCommand")
-    .sc(schemas_0.GetRun$)
+    .sc(GetRun$)
     .build() {
 }
 
-class GetRunGroupCommand extends client.Command
+class GetRunGroupCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "GetRunGroup", {})
     .n("OmicsClient", "GetRunGroupCommand")
-    .sc(schemas_0.GetRunGroup$)
+    .sc(GetRunGroup$)
     .build() {
 }
 
-class GetRunTaskCommand extends client.Command
+class GetRunTaskCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "GetRunTask", {})
     .n("OmicsClient", "GetRunTaskCommand")
-    .sc(schemas_0.GetRunTask$)
+    .sc(GetRunTask$)
     .build() {
 }
 
-class GetS3AccessPolicyCommand extends client.Command
+class GetS3AccessPolicyCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "GetS3AccessPolicy", {})
     .n("OmicsClient", "GetS3AccessPolicyCommand")
-    .sc(schemas_0.GetS3AccessPolicy$)
+    .sc(GetS3AccessPolicy$)
     .build() {
 }
 
-class GetSequenceStoreCommand extends client.Command
+class GetSequenceStoreCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "GetSequenceStore", {})
     .n("OmicsClient", "GetSequenceStoreCommand")
-    .sc(schemas_0.GetSequenceStore$)
+    .sc(GetSequenceStore$)
     .build() {
 }
 
-class GetShareCommand extends client.Command
+class GetShareCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "GetShare", {})
     .n("OmicsClient", "GetShareCommand")
-    .sc(schemas_0.GetShare$)
+    .sc(GetShare$)
     .build() {
 }
 
-class GetVariantImportJobCommand extends client.Command
+class GetVariantImportJobCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "GetVariantImportJob", {})
     .n("OmicsClient", "GetVariantImportJobCommand")
-    .sc(schemas_0.GetVariantImportJob$)
+    .sc(GetVariantImportJob$)
     .build() {
 }
 
-class GetVariantStoreCommand extends client.Command
+class GetVariantStoreCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "GetVariantStore", {})
     .n("OmicsClient", "GetVariantStoreCommand")
-    .sc(schemas_0.GetVariantStore$)
+    .sc(GetVariantStore$)
     .build() {
 }
 
-class GetWorkflowCommand extends client.Command
+class GetWorkflowCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "GetWorkflow", {})
     .n("OmicsClient", "GetWorkflowCommand")
-    .sc(schemas_0.GetWorkflow$)
+    .sc(GetWorkflow$)
     .build() {
 }
 
-class GetWorkflowVersionCommand extends client.Command
+class GetWorkflowVersionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "GetWorkflowVersion", {})
     .n("OmicsClient", "GetWorkflowVersionCommand")
-    .sc(schemas_0.GetWorkflowVersion$)
+    .sc(GetWorkflowVersion$)
     .build() {
 }
 
-class ListAnnotationImportJobsCommand extends client.Command
+class ListAnnotationImportJobsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "ListAnnotationImportJobs", {})
     .n("OmicsClient", "ListAnnotationImportJobsCommand")
-    .sc(schemas_0.ListAnnotationImportJobs$)
+    .sc(ListAnnotationImportJobs$)
     .build() {
 }
 
-class ListAnnotationStoresCommand extends client.Command
+class ListAnnotationStoresCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "ListAnnotationStores", {})
     .n("OmicsClient", "ListAnnotationStoresCommand")
-    .sc(schemas_0.ListAnnotationStores$)
+    .sc(ListAnnotationStores$)
     .build() {
 }
 
-class ListAnnotationStoreVersionsCommand extends client.Command
+class ListAnnotationStoreVersionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "ListAnnotationStoreVersions", {})
     .n("OmicsClient", "ListAnnotationStoreVersionsCommand")
-    .sc(schemas_0.ListAnnotationStoreVersions$)
+    .sc(ListAnnotationStoreVersions$)
     .build() {
 }
 
-class ListBatchCommand extends client.Command
+class ListBatchCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "ListBatch", {})
     .n("OmicsClient", "ListBatchCommand")
-    .sc(schemas_0.ListBatch$)
+    .sc(ListBatch$)
     .build() {
 }
 
-class ListConfigurationsCommand extends client.Command
+class ListConfigurationsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "ListConfigurations", {})
     .n("OmicsClient", "ListConfigurationsCommand")
-    .sc(schemas_0.ListConfigurations$)
+    .sc(ListConfigurations$)
     .build() {
 }
 
-class ListMultipartReadSetUploadsCommand extends client.Command
+class ListMultipartReadSetUploadsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "ListMultipartReadSetUploads", {})
     .n("OmicsClient", "ListMultipartReadSetUploadsCommand")
-    .sc(schemas_0.ListMultipartReadSetUploads$)
+    .sc(ListMultipartReadSetUploads$)
     .build() {
 }
 
-class ListReadSetActivationJobsCommand extends client.Command
+class ListReadSetActivationJobsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "ListReadSetActivationJobs", {})
     .n("OmicsClient", "ListReadSetActivationJobsCommand")
-    .sc(schemas_0.ListReadSetActivationJobs$)
+    .sc(ListReadSetActivationJobs$)
     .build() {
 }
 
-class ListReadSetExportJobsCommand extends client.Command
+class ListReadSetExportJobsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "ListReadSetExportJobs", {})
     .n("OmicsClient", "ListReadSetExportJobsCommand")
-    .sc(schemas_0.ListReadSetExportJobs$)
+    .sc(ListReadSetExportJobs$)
     .build() {
 }
 
-class ListReadSetImportJobsCommand extends client.Command
+class ListReadSetImportJobsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "ListReadSetImportJobs", {})
     .n("OmicsClient", "ListReadSetImportJobsCommand")
-    .sc(schemas_0.ListReadSetImportJobs$)
+    .sc(ListReadSetImportJobs$)
     .build() {
 }
 
-class ListReadSetsCommand extends client.Command
+class ListReadSetsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "ListReadSets", {})
     .n("OmicsClient", "ListReadSetsCommand")
-    .sc(schemas_0.ListReadSets$)
+    .sc(ListReadSets$)
     .build() {
 }
 
-class ListReadSetUploadPartsCommand extends client.Command
+class ListReadSetUploadPartsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "ListReadSetUploadParts", {})
     .n("OmicsClient", "ListReadSetUploadPartsCommand")
-    .sc(schemas_0.ListReadSetUploadParts$)
+    .sc(ListReadSetUploadParts$)
     .build() {
 }
 
-class ListReferenceImportJobsCommand extends client.Command
+class ListReferenceImportJobsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "ListReferenceImportJobs", {})
     .n("OmicsClient", "ListReferenceImportJobsCommand")
-    .sc(schemas_0.ListReferenceImportJobs$)
+    .sc(ListReferenceImportJobs$)
     .build() {
 }
 
-class ListReferencesCommand extends client.Command
+class ListReferencesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "ListReferences", {})
     .n("OmicsClient", "ListReferencesCommand")
-    .sc(schemas_0.ListReferences$)
+    .sc(ListReferences$)
     .build() {
 }
 
-class ListReferenceStoresCommand extends client.Command
+class ListReferenceStoresCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "ListReferenceStores", {})
     .n("OmicsClient", "ListReferenceStoresCommand")
-    .sc(schemas_0.ListReferenceStores$)
+    .sc(ListReferenceStores$)
     .build() {
 }
 
-class ListRunCachesCommand extends client.Command
+class ListRunCachesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "ListRunCaches", {})
     .n("OmicsClient", "ListRunCachesCommand")
-    .sc(schemas_0.ListRunCaches$)
+    .sc(ListRunCaches$)
     .build() {
 }
 
-class ListRunGroupsCommand extends client.Command
+class ListRunGroupsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "ListRunGroups", {})
     .n("OmicsClient", "ListRunGroupsCommand")
-    .sc(schemas_0.ListRunGroups$)
+    .sc(ListRunGroups$)
     .build() {
 }
 
-class ListRunsCommand extends client.Command
+class ListRunsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "ListRuns", {})
     .n("OmicsClient", "ListRunsCommand")
-    .sc(schemas_0.ListRuns$)
+    .sc(ListRuns$)
     .build() {
 }
 
-class ListRunsInBatchCommand extends client.Command
+class ListRunsInBatchCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "ListRunsInBatch", {})
     .n("OmicsClient", "ListRunsInBatchCommand")
-    .sc(schemas_0.ListRunsInBatch$)
+    .sc(ListRunsInBatch$)
     .build() {
 }
 
-class ListRunTasksCommand extends client.Command
+class ListRunTasksCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "ListRunTasks", {})
     .n("OmicsClient", "ListRunTasksCommand")
-    .sc(schemas_0.ListRunTasks$)
+    .sc(ListRunTasks$)
     .build() {
 }
 
-class ListSequenceStoresCommand extends client.Command
+class ListSequenceStoresCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "ListSequenceStores", {})
     .n("OmicsClient", "ListSequenceStoresCommand")
-    .sc(schemas_0.ListSequenceStores$)
+    .sc(ListSequenceStores$)
     .build() {
 }
 
-class ListSharesCommand extends client.Command
+class ListSharesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "ListShares", {})
     .n("OmicsClient", "ListSharesCommand")
-    .sc(schemas_0.ListShares$)
+    .sc(ListShares$)
     .build() {
 }
 
-class ListTagsForResourceCommand extends client.Command
+class ListTagsForResourceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "ListTagsForResource", {})
     .n("OmicsClient", "ListTagsForResourceCommand")
-    .sc(schemas_0.ListTagsForResource$)
+    .sc(ListTagsForResource$)
     .build() {
 }
 
-class ListVariantImportJobsCommand extends client.Command
+class ListVariantImportJobsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "ListVariantImportJobs", {})
     .n("OmicsClient", "ListVariantImportJobsCommand")
-    .sc(schemas_0.ListVariantImportJobs$)
+    .sc(ListVariantImportJobs$)
     .build() {
 }
 
-class ListVariantStoresCommand extends client.Command
+class ListVariantStoresCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "ListVariantStores", {})
     .n("OmicsClient", "ListVariantStoresCommand")
-    .sc(schemas_0.ListVariantStores$)
+    .sc(ListVariantStores$)
     .build() {
 }
 
-class ListWorkflowsCommand extends client.Command
+class ListWorkflowsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "ListWorkflows", {})
     .n("OmicsClient", "ListWorkflowsCommand")
-    .sc(schemas_0.ListWorkflows$)
+    .sc(ListWorkflows$)
     .build() {
 }
 
-class ListWorkflowVersionsCommand extends client.Command
+class ListWorkflowVersionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "ListWorkflowVersions", {})
     .n("OmicsClient", "ListWorkflowVersionsCommand")
-    .sc(schemas_0.ListWorkflowVersions$)
+    .sc(ListWorkflowVersions$)
     .build() {
 }
 
-class PutS3AccessPolicyCommand extends client.Command
+class PutS3AccessPolicyCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "PutS3AccessPolicy", {})
     .n("OmicsClient", "PutS3AccessPolicyCommand")
-    .sc(schemas_0.PutS3AccessPolicy$)
+    .sc(PutS3AccessPolicy$)
     .build() {
 }
 
-class StartAnnotationImportJobCommand extends client.Command
+class StartAnnotationImportJobCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "StartAnnotationImportJob", {})
     .n("OmicsClient", "StartAnnotationImportJobCommand")
-    .sc(schemas_0.StartAnnotationImportJob$)
+    .sc(StartAnnotationImportJob$)
     .build() {
 }
 
-class StartReadSetActivationJobCommand extends client.Command
+class StartReadSetActivationJobCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "StartReadSetActivationJob", {})
     .n("OmicsClient", "StartReadSetActivationJobCommand")
-    .sc(schemas_0.StartReadSetActivationJob$)
+    .sc(StartReadSetActivationJob$)
     .build() {
 }
 
-class StartReadSetExportJobCommand extends client.Command
+class StartReadSetExportJobCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "StartReadSetExportJob", {})
     .n("OmicsClient", "StartReadSetExportJobCommand")
-    .sc(schemas_0.StartReadSetExportJob$)
+    .sc(StartReadSetExportJob$)
     .build() {
 }
 
-class StartReadSetImportJobCommand extends client.Command
+class StartReadSetImportJobCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "StartReadSetImportJob", {})
     .n("OmicsClient", "StartReadSetImportJobCommand")
-    .sc(schemas_0.StartReadSetImportJob$)
+    .sc(StartReadSetImportJob$)
     .build() {
 }
 
-class StartReferenceImportJobCommand extends client.Command
+class StartReferenceImportJobCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "StartReferenceImportJob", {})
     .n("OmicsClient", "StartReferenceImportJobCommand")
-    .sc(schemas_0.StartReferenceImportJob$)
+    .sc(StartReferenceImportJob$)
     .build() {
 }
 
-class StartRunBatchCommand extends client.Command
+class StartRunBatchCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "StartRunBatch", {})
     .n("OmicsClient", "StartRunBatchCommand")
-    .sc(schemas_0.StartRunBatch$)
+    .sc(StartRunBatch$)
     .build() {
 }
 
-class StartRunCommand extends client.Command
+class StartRunCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "StartRun", {})
     .n("OmicsClient", "StartRunCommand")
-    .sc(schemas_0.StartRun$)
+    .sc(StartRun$)
     .build() {
 }
 
-class StartVariantImportJobCommand extends client.Command
+class StartVariantImportJobCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "StartVariantImportJob", {})
     .n("OmicsClient", "StartVariantImportJobCommand")
-    .sc(schemas_0.StartVariantImportJob$)
+    .sc(StartVariantImportJob$)
     .build() {
 }
 
-class TagResourceCommand extends client.Command
+class TagResourceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "TagResource", {})
     .n("OmicsClient", "TagResourceCommand")
-    .sc(schemas_0.TagResource$)
+    .sc(TagResource$)
     .build() {
 }
 
-class UntagResourceCommand extends client.Command
+class UntagResourceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "UntagResource", {})
     .n("OmicsClient", "UntagResourceCommand")
-    .sc(schemas_0.UntagResource$)
+    .sc(UntagResource$)
     .build() {
 }
 
-class UpdateAnnotationStoreCommand extends client.Command
+class UpdateAnnotationStoreCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "UpdateAnnotationStore", {})
     .n("OmicsClient", "UpdateAnnotationStoreCommand")
-    .sc(schemas_0.UpdateAnnotationStore$)
+    .sc(UpdateAnnotationStore$)
     .build() {
 }
 
-class UpdateAnnotationStoreVersionCommand extends client.Command
+class UpdateAnnotationStoreVersionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "UpdateAnnotationStoreVersion", {})
     .n("OmicsClient", "UpdateAnnotationStoreVersionCommand")
-    .sc(schemas_0.UpdateAnnotationStoreVersion$)
+    .sc(UpdateAnnotationStoreVersion$)
     .build() {
 }
 
-class UpdateRunCacheCommand extends client.Command
+class UpdateRunCacheCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "UpdateRunCache", {})
     .n("OmicsClient", "UpdateRunCacheCommand")
-    .sc(schemas_0.UpdateRunCache$)
+    .sc(UpdateRunCache$)
     .build() {
 }
 
-class UpdateRunGroupCommand extends client.Command
+class UpdateRunGroupCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "UpdateRunGroup", {})
     .n("OmicsClient", "UpdateRunGroupCommand")
-    .sc(schemas_0.UpdateRunGroup$)
+    .sc(UpdateRunGroup$)
     .build() {
 }
 
-class UpdateSequenceStoreCommand extends client.Command
+class UpdateSequenceStoreCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "UpdateSequenceStore", {})
     .n("OmicsClient", "UpdateSequenceStoreCommand")
-    .sc(schemas_0.UpdateSequenceStore$)
+    .sc(UpdateSequenceStore$)
     .build() {
 }
 
-class UpdateVariantStoreCommand extends client.Command
+class UpdateVariantStoreCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "UpdateVariantStore", {})
     .n("OmicsClient", "UpdateVariantStoreCommand")
-    .sc(schemas_0.UpdateVariantStore$)
+    .sc(UpdateVariantStore$)
     .build() {
 }
 
-class UpdateWorkflowCommand extends client.Command
+class UpdateWorkflowCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "UpdateWorkflow", {})
     .n("OmicsClient", "UpdateWorkflowCommand")
-    .sc(schemas_0.UpdateWorkflow$)
+    .sc(UpdateWorkflow$)
     .build() {
 }
 
-class UpdateWorkflowVersionCommand extends client.Command
+class UpdateWorkflowVersionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "UpdateWorkflowVersion", {})
     .n("OmicsClient", "UpdateWorkflowVersionCommand")
-    .sc(schemas_0.UpdateWorkflowVersion$)
+    .sc(UpdateWorkflowVersion$)
     .build() {
 }
 
-class UploadReadSetPartCommand extends client.Command
+class UploadReadSetPartCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Omics", "UploadReadSetPart", {})
     .n("OmicsClient", "UploadReadSetPartCommand")
-    .sc(schemas_0.UploadReadSetPart$)
+    .sc(UploadReadSetPart$)
     .build() {
 }
 
-const paginateListAnnotationImportJobs = core.createPaginator(OmicsClient, ListAnnotationImportJobsCommand, "nextToken", "nextToken", "maxResults");
+const paginateListAnnotationImportJobs = createPaginator(OmicsClient, ListAnnotationImportJobsCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListAnnotationStores = core.createPaginator(OmicsClient, ListAnnotationStoresCommand, "nextToken", "nextToken", "maxResults");
+const paginateListAnnotationStores = createPaginator(OmicsClient, ListAnnotationStoresCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListAnnotationStoreVersions = core.createPaginator(OmicsClient, ListAnnotationStoreVersionsCommand, "nextToken", "nextToken", "maxResults");
+const paginateListAnnotationStoreVersions = createPaginator(OmicsClient, ListAnnotationStoreVersionsCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListBatch = core.createPaginator(OmicsClient, ListBatchCommand, "startingToken", "nextToken", "maxItems");
+const paginateListBatch = createPaginator(OmicsClient, ListBatchCommand, "startingToken", "nextToken", "maxItems");
 
-const paginateListConfigurations = core.createPaginator(OmicsClient, ListConfigurationsCommand, "startingToken", "nextToken", "maxResults");
+const paginateListConfigurations = createPaginator(OmicsClient, ListConfigurationsCommand, "startingToken", "nextToken", "maxResults");
 
-const paginateListMultipartReadSetUploads = core.createPaginator(OmicsClient, ListMultipartReadSetUploadsCommand, "nextToken", "nextToken", "maxResults");
+const paginateListMultipartReadSetUploads = createPaginator(OmicsClient, ListMultipartReadSetUploadsCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListReadSetActivationJobs = core.createPaginator(OmicsClient, ListReadSetActivationJobsCommand, "nextToken", "nextToken", "maxResults");
+const paginateListReadSetActivationJobs = createPaginator(OmicsClient, ListReadSetActivationJobsCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListReadSetExportJobs = core.createPaginator(OmicsClient, ListReadSetExportJobsCommand, "nextToken", "nextToken", "maxResults");
+const paginateListReadSetExportJobs = createPaginator(OmicsClient, ListReadSetExportJobsCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListReadSetImportJobs = core.createPaginator(OmicsClient, ListReadSetImportJobsCommand, "nextToken", "nextToken", "maxResults");
+const paginateListReadSetImportJobs = createPaginator(OmicsClient, ListReadSetImportJobsCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListReadSets = core.createPaginator(OmicsClient, ListReadSetsCommand, "nextToken", "nextToken", "maxResults");
+const paginateListReadSets = createPaginator(OmicsClient, ListReadSetsCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListReadSetUploadParts = core.createPaginator(OmicsClient, ListReadSetUploadPartsCommand, "nextToken", "nextToken", "maxResults");
+const paginateListReadSetUploadParts = createPaginator(OmicsClient, ListReadSetUploadPartsCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListReferenceImportJobs = core.createPaginator(OmicsClient, ListReferenceImportJobsCommand, "nextToken", "nextToken", "maxResults");
+const paginateListReferenceImportJobs = createPaginator(OmicsClient, ListReferenceImportJobsCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListReferences = core.createPaginator(OmicsClient, ListReferencesCommand, "nextToken", "nextToken", "maxResults");
+const paginateListReferences = createPaginator(OmicsClient, ListReferencesCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListReferenceStores = core.createPaginator(OmicsClient, ListReferenceStoresCommand, "nextToken", "nextToken", "maxResults");
+const paginateListReferenceStores = createPaginator(OmicsClient, ListReferenceStoresCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListRunCaches = core.createPaginator(OmicsClient, ListRunCachesCommand, "startingToken", "nextToken", "maxResults");
+const paginateListRunCaches = createPaginator(OmicsClient, ListRunCachesCommand, "startingToken", "nextToken", "maxResults");
 
-const paginateListRunGroups = core.createPaginator(OmicsClient, ListRunGroupsCommand, "startingToken", "nextToken", "maxResults");
+const paginateListRunGroups = createPaginator(OmicsClient, ListRunGroupsCommand, "startingToken", "nextToken", "maxResults");
 
-const paginateListRunsInBatch = core.createPaginator(OmicsClient, ListRunsInBatchCommand, "startingToken", "nextToken", "maxItems");
+const paginateListRunsInBatch = createPaginator(OmicsClient, ListRunsInBatchCommand, "startingToken", "nextToken", "maxItems");
 
-const paginateListRuns = core.createPaginator(OmicsClient, ListRunsCommand, "startingToken", "nextToken", "maxResults");
+const paginateListRuns = createPaginator(OmicsClient, ListRunsCommand, "startingToken", "nextToken", "maxResults");
 
-const paginateListRunTasks = core.createPaginator(OmicsClient, ListRunTasksCommand, "startingToken", "nextToken", "maxResults");
+const paginateListRunTasks = createPaginator(OmicsClient, ListRunTasksCommand, "startingToken", "nextToken", "maxResults");
 
-const paginateListSequenceStores = core.createPaginator(OmicsClient, ListSequenceStoresCommand, "nextToken", "nextToken", "maxResults");
+const paginateListSequenceStores = createPaginator(OmicsClient, ListSequenceStoresCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListShares = core.createPaginator(OmicsClient, ListSharesCommand, "nextToken", "nextToken", "maxResults");
+const paginateListShares = createPaginator(OmicsClient, ListSharesCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListVariantImportJobs = core.createPaginator(OmicsClient, ListVariantImportJobsCommand, "nextToken", "nextToken", "maxResults");
+const paginateListVariantImportJobs = createPaginator(OmicsClient, ListVariantImportJobsCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListVariantStores = core.createPaginator(OmicsClient, ListVariantStoresCommand, "nextToken", "nextToken", "maxResults");
+const paginateListVariantStores = createPaginator(OmicsClient, ListVariantStoresCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListWorkflows = core.createPaginator(OmicsClient, ListWorkflowsCommand, "startingToken", "nextToken", "maxResults");
+const paginateListWorkflows = createPaginator(OmicsClient, ListWorkflowsCommand, "startingToken", "nextToken", "maxResults");
 
-const paginateListWorkflowVersions = core.createPaginator(OmicsClient, ListWorkflowVersionsCommand, "startingToken", "nextToken", "maxResults");
+const paginateListWorkflowVersions = createPaginator(OmicsClient, ListWorkflowVersionsCommand, "startingToken", "nextToken", "maxResults");
 
-const checkState$h = async (client$1, input) => {
+const checkState$h = async (client, input) => {
     let reason;
     try {
-        let result = await client$1.send(new GetAnnotationImportJobCommand(input));
+        let result = await client.send(new GetAnnotationImportJobCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.status;
             };
             if (returnComparator() === "SUBMITTED") {
-                return { state: client.WaiterState.RETRY, reason };
+                return { state: WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -1461,7 +1464,7 @@ const checkState$h = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "IN_PROGRESS") {
-                return { state: client.WaiterState.RETRY, reason };
+                return { state: WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -1470,7 +1473,7 @@ const checkState$h = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "FAILED") {
-                return { state: client.WaiterState.FAILURE, reason };
+                return { state: WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -1479,7 +1482,7 @@ const checkState$h = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "CANCELLED") {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1488,7 +1491,7 @@ const checkState$h = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "COMPLETED") {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1496,29 +1499,29 @@ const checkState$h = async (client$1, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForAnnotationImportJobCreated = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$h);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState$h);
 };
 const waitUntilAnnotationImportJobCreated = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$h);
-    return client.checkExceptions(result);
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$h);
+    return checkExceptions(result);
 };
 
-const checkState$g = async (client$1, input) => {
+const checkState$g = async (client, input) => {
     let reason;
     try {
-        let result = await client$1.send(new GetAnnotationStoreCommand(input));
+        let result = await client.send(new GetAnnotationStoreCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.status;
             };
             if (returnComparator() === "ACTIVE") {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1527,7 +1530,7 @@ const checkState$g = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "CREATING") {
-                return { state: client.WaiterState.RETRY, reason };
+                return { state: WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -1536,7 +1539,7 @@ const checkState$g = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "UPDATING") {
-                return { state: client.WaiterState.RETRY, reason };
+                return { state: WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -1545,7 +1548,7 @@ const checkState$g = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "FAILED") {
-                return { state: client.WaiterState.FAILURE, reason };
+                return { state: WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -1553,29 +1556,29 @@ const checkState$g = async (client$1, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForAnnotationStoreCreated = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$g);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState$g);
 };
 const waitUntilAnnotationStoreCreated = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$g);
-    return client.checkExceptions(result);
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$g);
+    return checkExceptions(result);
 };
 
-const checkState$f = async (client$1, input) => {
+const checkState$f = async (client, input) => {
     let reason;
     try {
-        let result = await client$1.send(new GetAnnotationStoreCommand(input));
+        let result = await client.send(new GetAnnotationStoreCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.status;
             };
             if (returnComparator() === "DELETED") {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1584,7 +1587,7 @@ const checkState$f = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "DELETING") {
-                return { state: client.WaiterState.RETRY, reason };
+                return { state: WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -1592,32 +1595,32 @@ const checkState$f = async (client$1, input) => {
     catch (exception) {
         reason = exception;
         if (exception.name === "ResourceNotFoundException") {
-            return { state: client.WaiterState.SUCCESS, reason };
+            return { state: WaiterState.SUCCESS, reason };
         }
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForAnnotationStoreDeleted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$f);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState$f);
 };
 const waitUntilAnnotationStoreDeleted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$f);
-    return client.checkExceptions(result);
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$f);
+    return checkExceptions(result);
 };
 
-const checkState$e = async (client$1, input) => {
+const checkState$e = async (client, input) => {
     let reason;
     try {
-        let result = await client$1.send(new GetAnnotationStoreVersionCommand(input));
+        let result = await client.send(new GetAnnotationStoreVersionCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.status;
             };
             if (returnComparator() === "ACTIVE") {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1626,7 +1629,7 @@ const checkState$e = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "CREATING") {
-                return { state: client.WaiterState.RETRY, reason };
+                return { state: WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -1635,7 +1638,7 @@ const checkState$e = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "UPDATING") {
-                return { state: client.WaiterState.RETRY, reason };
+                return { state: WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -1644,7 +1647,7 @@ const checkState$e = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "FAILED") {
-                return { state: client.WaiterState.FAILURE, reason };
+                return { state: WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -1652,29 +1655,29 @@ const checkState$e = async (client$1, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForAnnotationStoreVersionCreated = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$e);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState$e);
 };
 const waitUntilAnnotationStoreVersionCreated = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$e);
-    return client.checkExceptions(result);
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$e);
+    return checkExceptions(result);
 };
 
-const checkState$d = async (client$1, input) => {
+const checkState$d = async (client, input) => {
     let reason;
     try {
-        let result = await client$1.send(new GetAnnotationStoreVersionCommand(input));
+        let result = await client.send(new GetAnnotationStoreVersionCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.status;
             };
             if (returnComparator() === "DELETED") {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1683,7 +1686,7 @@ const checkState$d = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "DELETING") {
-                return { state: client.WaiterState.RETRY, reason };
+                return { state: WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -1691,32 +1694,32 @@ const checkState$d = async (client$1, input) => {
     catch (exception) {
         reason = exception;
         if (exception.name === "ResourceNotFoundException") {
-            return { state: client.WaiterState.SUCCESS, reason };
+            return { state: WaiterState.SUCCESS, reason };
         }
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForAnnotationStoreVersionDeleted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$d);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState$d);
 };
 const waitUntilAnnotationStoreVersionDeleted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$d);
-    return client.checkExceptions(result);
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$d);
+    return checkExceptions(result);
 };
 
-const checkState$c = async (client$1, input) => {
+const checkState$c = async (client, input) => {
     let reason;
     try {
-        let result = await client$1.send(new GetReadSetActivationJobCommand(input));
+        let result = await client.send(new GetReadSetActivationJobCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.status;
             };
             if (returnComparator() === "COMPLETED") {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1725,7 +1728,7 @@ const checkState$c = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "SUBMITTED") {
-                return { state: client.WaiterState.RETRY, reason };
+                return { state: WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -1734,7 +1737,7 @@ const checkState$c = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "IN_PROGRESS") {
-                return { state: client.WaiterState.RETRY, reason };
+                return { state: WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -1743,7 +1746,7 @@ const checkState$c = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "CANCELLING") {
-                return { state: client.WaiterState.RETRY, reason };
+                return { state: WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -1752,7 +1755,7 @@ const checkState$c = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "CANCELLED") {
-                return { state: client.WaiterState.FAILURE, reason };
+                return { state: WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -1761,7 +1764,7 @@ const checkState$c = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "FAILED") {
-                return { state: client.WaiterState.FAILURE, reason };
+                return { state: WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -1770,7 +1773,7 @@ const checkState$c = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "COMPLETED_WITH_FAILURES") {
-                return { state: client.WaiterState.FAILURE, reason };
+                return { state: WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -1778,29 +1781,29 @@ const checkState$c = async (client$1, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForReadSetActivationJobCompleted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$c);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState$c);
 };
 const waitUntilReadSetActivationJobCompleted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$c);
-    return client.checkExceptions(result);
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$c);
+    return checkExceptions(result);
 };
 
-const checkState$b = async (client$1, input) => {
+const checkState$b = async (client, input) => {
     let reason;
     try {
-        let result = await client$1.send(new GetReadSetExportJobCommand(input));
+        let result = await client.send(new GetReadSetExportJobCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.status;
             };
             if (returnComparator() === "COMPLETED") {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1809,7 +1812,7 @@ const checkState$b = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "SUBMITTED") {
-                return { state: client.WaiterState.RETRY, reason };
+                return { state: WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -1818,7 +1821,7 @@ const checkState$b = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "IN_PROGRESS") {
-                return { state: client.WaiterState.RETRY, reason };
+                return { state: WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -1827,7 +1830,7 @@ const checkState$b = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "CANCELLING") {
-                return { state: client.WaiterState.RETRY, reason };
+                return { state: WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -1836,7 +1839,7 @@ const checkState$b = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "CANCELLED") {
-                return { state: client.WaiterState.FAILURE, reason };
+                return { state: WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -1845,7 +1848,7 @@ const checkState$b = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "FAILED") {
-                return { state: client.WaiterState.FAILURE, reason };
+                return { state: WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -1854,7 +1857,7 @@ const checkState$b = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "COMPLETED_WITH_FAILURES") {
-                return { state: client.WaiterState.FAILURE, reason };
+                return { state: WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -1862,29 +1865,29 @@ const checkState$b = async (client$1, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForReadSetExportJobCompleted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$b);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState$b);
 };
 const waitUntilReadSetExportJobCompleted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$b);
-    return client.checkExceptions(result);
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$b);
+    return checkExceptions(result);
 };
 
-const checkState$a = async (client$1, input) => {
+const checkState$a = async (client, input) => {
     let reason;
     try {
-        let result = await client$1.send(new GetReadSetImportJobCommand(input));
+        let result = await client.send(new GetReadSetImportJobCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.status;
             };
             if (returnComparator() === "COMPLETED") {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1893,7 +1896,7 @@ const checkState$a = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "SUBMITTED") {
-                return { state: client.WaiterState.RETRY, reason };
+                return { state: WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -1902,7 +1905,7 @@ const checkState$a = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "IN_PROGRESS") {
-                return { state: client.WaiterState.RETRY, reason };
+                return { state: WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -1911,7 +1914,7 @@ const checkState$a = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "CANCELLING") {
-                return { state: client.WaiterState.RETRY, reason };
+                return { state: WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -1920,7 +1923,7 @@ const checkState$a = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "CANCELLED") {
-                return { state: client.WaiterState.FAILURE, reason };
+                return { state: WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -1929,7 +1932,7 @@ const checkState$a = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "FAILED") {
-                return { state: client.WaiterState.FAILURE, reason };
+                return { state: WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -1938,7 +1941,7 @@ const checkState$a = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "COMPLETED_WITH_FAILURES") {
-                return { state: client.WaiterState.FAILURE, reason };
+                return { state: WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -1946,29 +1949,29 @@ const checkState$a = async (client$1, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForReadSetImportJobCompleted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$a);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState$a);
 };
 const waitUntilReadSetImportJobCompleted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$a);
-    return client.checkExceptions(result);
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$a);
+    return checkExceptions(result);
 };
 
-const checkState$9 = async (client$1, input) => {
+const checkState$9 = async (client, input) => {
     let reason;
     try {
-        let result = await client$1.send(new GetReferenceImportJobCommand(input));
+        let result = await client.send(new GetReferenceImportJobCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.status;
             };
             if (returnComparator() === "COMPLETED") {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1977,7 +1980,7 @@ const checkState$9 = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "SUBMITTED") {
-                return { state: client.WaiterState.RETRY, reason };
+                return { state: WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -1986,7 +1989,7 @@ const checkState$9 = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "IN_PROGRESS") {
-                return { state: client.WaiterState.RETRY, reason };
+                return { state: WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -1995,7 +1998,7 @@ const checkState$9 = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "CANCELLING") {
-                return { state: client.WaiterState.RETRY, reason };
+                return { state: WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2004,7 +2007,7 @@ const checkState$9 = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "CANCELLED") {
-                return { state: client.WaiterState.FAILURE, reason };
+                return { state: WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -2013,7 +2016,7 @@ const checkState$9 = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "FAILED") {
-                return { state: client.WaiterState.FAILURE, reason };
+                return { state: WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -2022,7 +2025,7 @@ const checkState$9 = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "COMPLETED_WITH_FAILURES") {
-                return { state: client.WaiterState.FAILURE, reason };
+                return { state: WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -2030,29 +2033,29 @@ const checkState$9 = async (client$1, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForReferenceImportJobCompleted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$9);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState$9);
 };
 const waitUntilReferenceImportJobCompleted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$9);
-    return client.checkExceptions(result);
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$9);
+    return checkExceptions(result);
 };
 
-const checkState$8 = async (client$1, input) => {
+const checkState$8 = async (client, input) => {
     let reason;
     try {
-        let result = await client$1.send(new GetRunCommand(input));
+        let result = await client.send(new GetRunCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.status;
             };
             if (returnComparator() === "COMPLETED") {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -2061,7 +2064,7 @@ const checkState$8 = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "PENDING") {
-                return { state: client.WaiterState.RETRY, reason };
+                return { state: WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2070,7 +2073,7 @@ const checkState$8 = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "STARTING") {
-                return { state: client.WaiterState.RETRY, reason };
+                return { state: WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2079,7 +2082,7 @@ const checkState$8 = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "RUNNING") {
-                return { state: client.WaiterState.RETRY, reason };
+                return { state: WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2088,7 +2091,7 @@ const checkState$8 = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "STOPPING") {
-                return { state: client.WaiterState.RETRY, reason };
+                return { state: WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2097,7 +2100,7 @@ const checkState$8 = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "FAILED") {
-                return { state: client.WaiterState.FAILURE, reason };
+                return { state: WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -2105,29 +2108,29 @@ const checkState$8 = async (client$1, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForRunCompleted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$8);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState$8);
 };
 const waitUntilRunCompleted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$8);
-    return client.checkExceptions(result);
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$8);
+    return checkExceptions(result);
 };
 
-const checkState$7 = async (client$1, input) => {
+const checkState$7 = async (client, input) => {
     let reason;
     try {
-        let result = await client$1.send(new GetRunCommand(input));
+        let result = await client.send(new GetRunCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.status;
             };
             if (returnComparator() === "RUNNING") {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -2136,7 +2139,7 @@ const checkState$7 = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "PENDING") {
-                return { state: client.WaiterState.RETRY, reason };
+                return { state: WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2145,7 +2148,7 @@ const checkState$7 = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "STARTING") {
-                return { state: client.WaiterState.RETRY, reason };
+                return { state: WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2154,7 +2157,7 @@ const checkState$7 = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "FAILED") {
-                return { state: client.WaiterState.FAILURE, reason };
+                return { state: WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -2163,7 +2166,7 @@ const checkState$7 = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "CANCELLED") {
-                return { state: client.WaiterState.FAILURE, reason };
+                return { state: WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -2171,29 +2174,29 @@ const checkState$7 = async (client$1, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForRunRunning = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$7);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState$7);
 };
 const waitUntilRunRunning = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$7);
-    return client.checkExceptions(result);
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$7);
+    return checkExceptions(result);
 };
 
-const checkState$6 = async (client$1, input) => {
+const checkState$6 = async (client, input) => {
     let reason;
     try {
-        let result = await client$1.send(new GetRunTaskCommand(input));
+        let result = await client.send(new GetRunTaskCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.status;
             };
             if (returnComparator() === "COMPLETED") {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -2202,7 +2205,7 @@ const checkState$6 = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "PENDING") {
-                return { state: client.WaiterState.RETRY, reason };
+                return { state: WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2211,7 +2214,7 @@ const checkState$6 = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "STARTING") {
-                return { state: client.WaiterState.RETRY, reason };
+                return { state: WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2220,7 +2223,7 @@ const checkState$6 = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "RUNNING") {
-                return { state: client.WaiterState.RETRY, reason };
+                return { state: WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2229,7 +2232,7 @@ const checkState$6 = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "STOPPING") {
-                return { state: client.WaiterState.RETRY, reason };
+                return { state: WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2238,7 +2241,7 @@ const checkState$6 = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "FAILED") {
-                return { state: client.WaiterState.FAILURE, reason };
+                return { state: WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -2246,29 +2249,29 @@ const checkState$6 = async (client$1, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForTaskCompleted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$6);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState$6);
 };
 const waitUntilTaskCompleted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$6);
-    return client.checkExceptions(result);
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$6);
+    return checkExceptions(result);
 };
 
-const checkState$5 = async (client$1, input) => {
+const checkState$5 = async (client, input) => {
     let reason;
     try {
-        let result = await client$1.send(new GetRunTaskCommand(input));
+        let result = await client.send(new GetRunTaskCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.status;
             };
             if (returnComparator() === "RUNNING") {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -2277,7 +2280,7 @@ const checkState$5 = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "PENDING") {
-                return { state: client.WaiterState.RETRY, reason };
+                return { state: WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2286,7 +2289,7 @@ const checkState$5 = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "STARTING") {
-                return { state: client.WaiterState.RETRY, reason };
+                return { state: WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2295,7 +2298,7 @@ const checkState$5 = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "FAILED") {
-                return { state: client.WaiterState.FAILURE, reason };
+                return { state: WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -2304,7 +2307,7 @@ const checkState$5 = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "CANCELLED") {
-                return { state: client.WaiterState.FAILURE, reason };
+                return { state: WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -2312,29 +2315,29 @@ const checkState$5 = async (client$1, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForTaskRunning = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$5);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState$5);
 };
 const waitUntilTaskRunning = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$5);
-    return client.checkExceptions(result);
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$5);
+    return checkExceptions(result);
 };
 
-const checkState$4 = async (client$1, input) => {
+const checkState$4 = async (client, input) => {
     let reason;
     try {
-        let result = await client$1.send(new GetVariantImportJobCommand(input));
+        let result = await client.send(new GetVariantImportJobCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.status;
             };
             if (returnComparator() === "SUBMITTED") {
-                return { state: client.WaiterState.RETRY, reason };
+                return { state: WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2343,7 +2346,7 @@ const checkState$4 = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "IN_PROGRESS") {
-                return { state: client.WaiterState.RETRY, reason };
+                return { state: WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2352,7 +2355,7 @@ const checkState$4 = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "FAILED") {
-                return { state: client.WaiterState.FAILURE, reason };
+                return { state: WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -2361,7 +2364,7 @@ const checkState$4 = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "CANCELLED") {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -2370,7 +2373,7 @@ const checkState$4 = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "COMPLETED") {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -2378,29 +2381,29 @@ const checkState$4 = async (client$1, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForVariantImportJobCreated = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$4);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState$4);
 };
 const waitUntilVariantImportJobCreated = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$4);
-    return client.checkExceptions(result);
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$4);
+    return checkExceptions(result);
 };
 
-const checkState$3 = async (client$1, input) => {
+const checkState$3 = async (client, input) => {
     let reason;
     try {
-        let result = await client$1.send(new GetVariantStoreCommand(input));
+        let result = await client.send(new GetVariantStoreCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.status;
             };
             if (returnComparator() === "ACTIVE") {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -2409,7 +2412,7 @@ const checkState$3 = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "CREATING") {
-                return { state: client.WaiterState.RETRY, reason };
+                return { state: WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2418,7 +2421,7 @@ const checkState$3 = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "UPDATING") {
-                return { state: client.WaiterState.RETRY, reason };
+                return { state: WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2427,7 +2430,7 @@ const checkState$3 = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "FAILED") {
-                return { state: client.WaiterState.FAILURE, reason };
+                return { state: WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -2435,29 +2438,29 @@ const checkState$3 = async (client$1, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForVariantStoreCreated = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
 };
 const waitUntilVariantStoreCreated = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
-    return client.checkExceptions(result);
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
+    return checkExceptions(result);
 };
 
-const checkState$2 = async (client$1, input) => {
+const checkState$2 = async (client, input) => {
     let reason;
     try {
-        let result = await client$1.send(new GetVariantStoreCommand(input));
+        let result = await client.send(new GetVariantStoreCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.status;
             };
             if (returnComparator() === "DELETED") {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -2466,7 +2469,7 @@ const checkState$2 = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "DELETING") {
-                return { state: client.WaiterState.RETRY, reason };
+                return { state: WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2474,32 +2477,32 @@ const checkState$2 = async (client$1, input) => {
     catch (exception) {
         reason = exception;
         if (exception.name === "ResourceNotFoundException") {
-            return { state: client.WaiterState.SUCCESS, reason };
+            return { state: WaiterState.SUCCESS, reason };
         }
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForVariantStoreDeleted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
 };
 const waitUntilVariantStoreDeleted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
-    return client.checkExceptions(result);
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
+    return checkExceptions(result);
 };
 
-const checkState$1 = async (client$1, input) => {
+const checkState$1 = async (client, input) => {
     let reason;
     try {
-        let result = await client$1.send(new GetWorkflowCommand(input));
+        let result = await client.send(new GetWorkflowCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.status;
             };
             if (returnComparator() === "ACTIVE") {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -2508,7 +2511,7 @@ const checkState$1 = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "CREATING") {
-                return { state: client.WaiterState.RETRY, reason };
+                return { state: WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2517,7 +2520,7 @@ const checkState$1 = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "UPDATING") {
-                return { state: client.WaiterState.RETRY, reason };
+                return { state: WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2526,7 +2529,7 @@ const checkState$1 = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "FAILED") {
-                return { state: client.WaiterState.FAILURE, reason };
+                return { state: WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -2534,29 +2537,29 @@ const checkState$1 = async (client$1, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForWorkflowActive = async (params, input) => {
     const serviceDefaults = { minDelay: 3, maxDelay: 30 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
 };
 const waitUntilWorkflowActive = async (params, input) => {
     const serviceDefaults = { minDelay: 3, maxDelay: 30 };
-    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
-    return client.checkExceptions(result);
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
+    return checkExceptions(result);
 };
 
-const checkState = async (client$1, input) => {
+const checkState = async (client, input) => {
     let reason;
     try {
-        let result = await client$1.send(new GetWorkflowVersionCommand(input));
+        let result = await client.send(new GetWorkflowVersionCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.status;
             };
             if (returnComparator() === "ACTIVE") {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -2565,7 +2568,7 @@ const checkState = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "CREATING") {
-                return { state: client.WaiterState.RETRY, reason };
+                return { state: WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2574,7 +2577,7 @@ const checkState = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "UPDATING") {
-                return { state: client.WaiterState.RETRY, reason };
+                return { state: WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -2583,7 +2586,7 @@ const checkState = async (client$1, input) => {
                 return result.status;
             };
             if (returnComparator() === "FAILED") {
-                return { state: client.WaiterState.FAILURE, reason };
+                return { state: WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -2591,16 +2594,16 @@ const checkState = async (client$1, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForWorkflowVersionActive = async (params, input) => {
     const serviceDefaults = { minDelay: 3, maxDelay: 30 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
 const waitUntilWorkflowVersionActive = async (params, input) => {
     const serviceDefaults = { minDelay: 3, maxDelay: 30 };
-    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState);
-    return client.checkExceptions(result);
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
 };
 
 const commands = {
@@ -2761,7 +2764,7 @@ const waiters = {
 };
 class Omics extends OmicsClient {
 }
-client.createAggregatedClient(commands, Omics, { paginators, waiters });
+createAggregatedClient(commands, Omics, { paginators, waiters });
 
 const Accelerators = {
     GPU: "GPU",
@@ -3070,9 +3073,6 @@ const ResourceOwner = {
     SELF: "SELF",
 };
 
-exports.$Command = client.Command;
-exports.__Client = client.Client;
-exports.OmicsServiceException = OmicsServiceException.OmicsServiceException;
 exports.AbortMultipartReadSetUploadCommand = AbortMultipartReadSetUploadCommand;
 exports.Accelerators = Accelerators;
 exports.AcceptShareCommand = AcceptShareCommand;
@@ -3292,23 +3292,3 @@ exports.waitUntilVariantStoreCreated = waitUntilVariantStoreCreated;
 exports.waitUntilVariantStoreDeleted = waitUntilVariantStoreDeleted;
 exports.waitUntilWorkflowActive = waitUntilWorkflowActive;
 exports.waitUntilWorkflowVersionActive = waitUntilWorkflowVersionActive;
-Object.prototype.hasOwnProperty.call(schemas_0, '__proto__') &&
-    !Object.prototype.hasOwnProperty.call(exports, '__proto__') &&
-    Object.defineProperty(exports, '__proto__', {
-        enumerable: true,
-        value: schemas_0['__proto__']
-    });
-
-Object.keys(schemas_0).forEach(function (k) {
-    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = schemas_0[k];
-});
-Object.prototype.hasOwnProperty.call(errors, '__proto__') &&
-    !Object.prototype.hasOwnProperty.call(exports, '__proto__') &&
-    Object.defineProperty(exports, '__proto__', {
-        enumerable: true,
-        value: errors['__proto__']
-    });
-
-Object.keys(errors).forEach(function (k) {
-    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = errors[k];
-});