@aws-sdk/client-emr 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 EMRServiceException = require('./models/EMRServiceException');
+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, defaultEMRHttpAuthSchemeParametersProvider } = require("./auth/httpAuthSchemeProvider");
+const { getRuntimeConfig } = require("./runtimeConfig");
+const { AddInstanceFleet$, AddInstanceGroups$, AddJobFlowSteps$, AddTags$, CancelSteps$, CreatePersistentAppUI$, CreateSecurityConfiguration$, CreateStudio$, CreateStudioSessionMapping$, DeleteSecurityConfiguration$, DeleteStudio$, DeleteStudioSessionMapping$, DescribeCluster$, DescribeJobFlows$, DescribeNotebookExecution$, DescribePersistentAppUI$, DescribeReleaseLabel$, DescribeSecurityConfiguration$, DescribeStep$, DescribeStudio$, GetAutoTerminationPolicy$, GetBlockPublicAccessConfiguration$, GetClusterSessionCredentials$, GetManagedScalingPolicy$, GetOnClusterAppUIPresignedURL$, GetPersistentAppUIPresignedURL$, GetSession$, GetSessionEndpoint$, GetStudioSessionMapping$, ListBootstrapActions$, ListClusters$, ListInstanceFleets$, ListInstanceGroups$, ListInstances$, ListNotebookExecutions$, ListReleaseLabels$, ListSecurityConfigurations$, ListSessions$, ListSteps$, ListStudios$, ListStudioSessionMappings$, ListSupportedInstanceTypes$, ModifyCluster$, ModifyInstanceFleet$, ModifyInstanceGroups$, PutAutoScalingPolicy$, PutAutoTerminationPolicy$, PutBlockPublicAccessConfiguration$, PutManagedScalingPolicy$, RemoveAutoScalingPolicy$, RemoveAutoTerminationPolicy$, RemoveManagedScalingPolicy$, RemoveTags$, RunJobFlow$, SetKeepJobFlowAliveWhenNoSteps$, SetTerminationProtection$, SetUnhealthyNodeReplacement$, SetVisibleToAllUsers$, StartNotebookExecution$, StartSession$, StopNotebookExecution$, TerminateJobFlows$, TerminateSession$, UpdateStudio$, UpdateStudioSessionMapping$ } = require("./schemas/schemas_0");
+__exportStar(require("./schemas/schemas_0"), exports);
+__exportStar(require("./models/errors"), exports);
+const { EMRServiceException } = require("./models/EMRServiceException");
+exports.EMRServiceException = EMRServiceException;
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -68,863 +71,863 @@ 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 EMRClient extends client.Client {
+class EMRClient 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.defaultEMRHttpAuthSchemeParametersProvider,
-            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: defaultEMRHttpAuthSchemeParametersProvider,
+            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 AddInstanceFleetCommand extends client.Command
+class AddInstanceFleetCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "AddInstanceFleet", {})
     .n("EMRClient", "AddInstanceFleetCommand")
-    .sc(schemas_0.AddInstanceFleet$)
+    .sc(AddInstanceFleet$)
     .build() {
 }
 
-class AddInstanceGroupsCommand extends client.Command
+class AddInstanceGroupsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "AddInstanceGroups", {})
     .n("EMRClient", "AddInstanceGroupsCommand")
-    .sc(schemas_0.AddInstanceGroups$)
+    .sc(AddInstanceGroups$)
     .build() {
 }
 
-class AddJobFlowStepsCommand extends client.Command
+class AddJobFlowStepsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "AddJobFlowSteps", {})
     .n("EMRClient", "AddJobFlowStepsCommand")
-    .sc(schemas_0.AddJobFlowSteps$)
+    .sc(AddJobFlowSteps$)
     .build() {
 }
 
-class AddTagsCommand extends client.Command
+class AddTagsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "AddTags", {})
     .n("EMRClient", "AddTagsCommand")
-    .sc(schemas_0.AddTags$)
+    .sc(AddTags$)
     .build() {
 }
 
-class CancelStepsCommand extends client.Command
+class CancelStepsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "CancelSteps", {})
     .n("EMRClient", "CancelStepsCommand")
-    .sc(schemas_0.CancelSteps$)
+    .sc(CancelSteps$)
     .build() {
 }
 
-class CreatePersistentAppUICommand extends client.Command
+class CreatePersistentAppUICommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "CreatePersistentAppUI", {})
     .n("EMRClient", "CreatePersistentAppUICommand")
-    .sc(schemas_0.CreatePersistentAppUI$)
+    .sc(CreatePersistentAppUI$)
     .build() {
 }
 
-class CreateSecurityConfigurationCommand extends client.Command
+class CreateSecurityConfigurationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "CreateSecurityConfiguration", {})
     .n("EMRClient", "CreateSecurityConfigurationCommand")
-    .sc(schemas_0.CreateSecurityConfiguration$)
+    .sc(CreateSecurityConfiguration$)
     .build() {
 }
 
-class CreateStudioCommand extends client.Command
+class CreateStudioCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "CreateStudio", {})
     .n("EMRClient", "CreateStudioCommand")
-    .sc(schemas_0.CreateStudio$)
+    .sc(CreateStudio$)
     .build() {
 }
 
-class CreateStudioSessionMappingCommand extends client.Command
+class CreateStudioSessionMappingCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "CreateStudioSessionMapping", {})
     .n("EMRClient", "CreateStudioSessionMappingCommand")
-    .sc(schemas_0.CreateStudioSessionMapping$)
+    .sc(CreateStudioSessionMapping$)
     .build() {
 }
 
-class DeleteSecurityConfigurationCommand extends client.Command
+class DeleteSecurityConfigurationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "DeleteSecurityConfiguration", {})
     .n("EMRClient", "DeleteSecurityConfigurationCommand")
-    .sc(schemas_0.DeleteSecurityConfiguration$)
+    .sc(DeleteSecurityConfiguration$)
     .build() {
 }
 
-class DeleteStudioCommand extends client.Command
+class DeleteStudioCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "DeleteStudio", {})
     .n("EMRClient", "DeleteStudioCommand")
-    .sc(schemas_0.DeleteStudio$)
+    .sc(DeleteStudio$)
     .build() {
 }
 
-class DeleteStudioSessionMappingCommand extends client.Command
+class DeleteStudioSessionMappingCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "DeleteStudioSessionMapping", {})
     .n("EMRClient", "DeleteStudioSessionMappingCommand")
-    .sc(schemas_0.DeleteStudioSessionMapping$)
+    .sc(DeleteStudioSessionMapping$)
     .build() {
 }
 
-class DescribeClusterCommand extends client.Command
+class DescribeClusterCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "DescribeCluster", {})
     .n("EMRClient", "DescribeClusterCommand")
-    .sc(schemas_0.DescribeCluster$)
+    .sc(DescribeCluster$)
     .build() {
 }
 
-class DescribeJobFlowsCommand extends client.Command
+class DescribeJobFlowsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "DescribeJobFlows", {})
     .n("EMRClient", "DescribeJobFlowsCommand")
-    .sc(schemas_0.DescribeJobFlows$)
+    .sc(DescribeJobFlows$)
     .build() {
 }
 
-class DescribeNotebookExecutionCommand extends client.Command
+class DescribeNotebookExecutionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "DescribeNotebookExecution", {})
     .n("EMRClient", "DescribeNotebookExecutionCommand")
-    .sc(schemas_0.DescribeNotebookExecution$)
+    .sc(DescribeNotebookExecution$)
     .build() {
 }
 
-class DescribePersistentAppUICommand extends client.Command
+class DescribePersistentAppUICommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "DescribePersistentAppUI", {})
     .n("EMRClient", "DescribePersistentAppUICommand")
-    .sc(schemas_0.DescribePersistentAppUI$)
+    .sc(DescribePersistentAppUI$)
     .build() {
 }
 
-class DescribeReleaseLabelCommand extends client.Command
+class DescribeReleaseLabelCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "DescribeReleaseLabel", {})
     .n("EMRClient", "DescribeReleaseLabelCommand")
-    .sc(schemas_0.DescribeReleaseLabel$)
+    .sc(DescribeReleaseLabel$)
     .build() {
 }
 
-class DescribeSecurityConfigurationCommand extends client.Command
+class DescribeSecurityConfigurationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "DescribeSecurityConfiguration", {})
     .n("EMRClient", "DescribeSecurityConfigurationCommand")
-    .sc(schemas_0.DescribeSecurityConfiguration$)
+    .sc(DescribeSecurityConfiguration$)
     .build() {
 }
 
-class DescribeStepCommand extends client.Command
+class DescribeStepCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "DescribeStep", {})
     .n("EMRClient", "DescribeStepCommand")
-    .sc(schemas_0.DescribeStep$)
+    .sc(DescribeStep$)
     .build() {
 }
 
-class DescribeStudioCommand extends client.Command
+class DescribeStudioCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "DescribeStudio", {})
     .n("EMRClient", "DescribeStudioCommand")
-    .sc(schemas_0.DescribeStudio$)
+    .sc(DescribeStudio$)
     .build() {
 }
 
-class GetAutoTerminationPolicyCommand extends client.Command
+class GetAutoTerminationPolicyCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "GetAutoTerminationPolicy", {})
     .n("EMRClient", "GetAutoTerminationPolicyCommand")
-    .sc(schemas_0.GetAutoTerminationPolicy$)
+    .sc(GetAutoTerminationPolicy$)
     .build() {
 }
 
-class GetBlockPublicAccessConfigurationCommand extends client.Command
+class GetBlockPublicAccessConfigurationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "GetBlockPublicAccessConfiguration", {})
     .n("EMRClient", "GetBlockPublicAccessConfigurationCommand")
-    .sc(schemas_0.GetBlockPublicAccessConfiguration$)
+    .sc(GetBlockPublicAccessConfiguration$)
     .build() {
 }
 
-class GetClusterSessionCredentialsCommand extends client.Command
+class GetClusterSessionCredentialsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "GetClusterSessionCredentials", {})
     .n("EMRClient", "GetClusterSessionCredentialsCommand")
-    .sc(schemas_0.GetClusterSessionCredentials$)
+    .sc(GetClusterSessionCredentials$)
     .build() {
 }
 
-class GetManagedScalingPolicyCommand extends client.Command
+class GetManagedScalingPolicyCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "GetManagedScalingPolicy", {})
     .n("EMRClient", "GetManagedScalingPolicyCommand")
-    .sc(schemas_0.GetManagedScalingPolicy$)
+    .sc(GetManagedScalingPolicy$)
     .build() {
 }
 
-class GetOnClusterAppUIPresignedURLCommand extends client.Command
+class GetOnClusterAppUIPresignedURLCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "GetOnClusterAppUIPresignedURL", {})
     .n("EMRClient", "GetOnClusterAppUIPresignedURLCommand")
-    .sc(schemas_0.GetOnClusterAppUIPresignedURL$)
+    .sc(GetOnClusterAppUIPresignedURL$)
     .build() {
 }
 
-class GetPersistentAppUIPresignedURLCommand extends client.Command
+class GetPersistentAppUIPresignedURLCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "GetPersistentAppUIPresignedURL", {})
     .n("EMRClient", "GetPersistentAppUIPresignedURLCommand")
-    .sc(schemas_0.GetPersistentAppUIPresignedURL$)
+    .sc(GetPersistentAppUIPresignedURL$)
     .build() {
 }
 
-class GetSessionCommand extends client.Command
+class GetSessionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "GetSession", {})
     .n("EMRClient", "GetSessionCommand")
-    .sc(schemas_0.GetSession$)
+    .sc(GetSession$)
     .build() {
 }
 
-class GetSessionEndpointCommand extends client.Command
+class GetSessionEndpointCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "GetSessionEndpoint", {})
     .n("EMRClient", "GetSessionEndpointCommand")
-    .sc(schemas_0.GetSessionEndpoint$)
+    .sc(GetSessionEndpoint$)
     .build() {
 }
 
-class GetStudioSessionMappingCommand extends client.Command
+class GetStudioSessionMappingCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "GetStudioSessionMapping", {})
     .n("EMRClient", "GetStudioSessionMappingCommand")
-    .sc(schemas_0.GetStudioSessionMapping$)
+    .sc(GetStudioSessionMapping$)
     .build() {
 }
 
-class ListBootstrapActionsCommand extends client.Command
+class ListBootstrapActionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "ListBootstrapActions", {})
     .n("EMRClient", "ListBootstrapActionsCommand")
-    .sc(schemas_0.ListBootstrapActions$)
+    .sc(ListBootstrapActions$)
     .build() {
 }
 
-class ListClustersCommand extends client.Command
+class ListClustersCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "ListClusters", {})
     .n("EMRClient", "ListClustersCommand")
-    .sc(schemas_0.ListClusters$)
+    .sc(ListClusters$)
     .build() {
 }
 
-class ListInstanceFleetsCommand extends client.Command
+class ListInstanceFleetsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "ListInstanceFleets", {})
     .n("EMRClient", "ListInstanceFleetsCommand")
-    .sc(schemas_0.ListInstanceFleets$)
+    .sc(ListInstanceFleets$)
     .build() {
 }
 
-class ListInstanceGroupsCommand extends client.Command
+class ListInstanceGroupsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "ListInstanceGroups", {})
     .n("EMRClient", "ListInstanceGroupsCommand")
-    .sc(schemas_0.ListInstanceGroups$)
+    .sc(ListInstanceGroups$)
     .build() {
 }
 
-class ListInstancesCommand extends client.Command
+class ListInstancesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "ListInstances", {})
     .n("EMRClient", "ListInstancesCommand")
-    .sc(schemas_0.ListInstances$)
+    .sc(ListInstances$)
     .build() {
 }
 
-class ListNotebookExecutionsCommand extends client.Command
+class ListNotebookExecutionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "ListNotebookExecutions", {})
     .n("EMRClient", "ListNotebookExecutionsCommand")
-    .sc(schemas_0.ListNotebookExecutions$)
+    .sc(ListNotebookExecutions$)
     .build() {
 }
 
-class ListReleaseLabelsCommand extends client.Command
+class ListReleaseLabelsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "ListReleaseLabels", {})
     .n("EMRClient", "ListReleaseLabelsCommand")
-    .sc(schemas_0.ListReleaseLabels$)
+    .sc(ListReleaseLabels$)
     .build() {
 }
 
-class ListSecurityConfigurationsCommand extends client.Command
+class ListSecurityConfigurationsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "ListSecurityConfigurations", {})
     .n("EMRClient", "ListSecurityConfigurationsCommand")
-    .sc(schemas_0.ListSecurityConfigurations$)
+    .sc(ListSecurityConfigurations$)
     .build() {
 }
 
-class ListSessionsCommand extends client.Command
+class ListSessionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "ListSessions", {})
     .n("EMRClient", "ListSessionsCommand")
-    .sc(schemas_0.ListSessions$)
+    .sc(ListSessions$)
     .build() {
 }
 
-class ListStepsCommand extends client.Command
+class ListStepsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "ListSteps", {})
     .n("EMRClient", "ListStepsCommand")
-    .sc(schemas_0.ListSteps$)
+    .sc(ListSteps$)
     .build() {
 }
 
-class ListStudiosCommand extends client.Command
+class ListStudiosCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "ListStudios", {})
     .n("EMRClient", "ListStudiosCommand")
-    .sc(schemas_0.ListStudios$)
+    .sc(ListStudios$)
     .build() {
 }
 
-class ListStudioSessionMappingsCommand extends client.Command
+class ListStudioSessionMappingsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "ListStudioSessionMappings", {})
     .n("EMRClient", "ListStudioSessionMappingsCommand")
-    .sc(schemas_0.ListStudioSessionMappings$)
+    .sc(ListStudioSessionMappings$)
     .build() {
 }
 
-class ListSupportedInstanceTypesCommand extends client.Command
+class ListSupportedInstanceTypesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "ListSupportedInstanceTypes", {})
     .n("EMRClient", "ListSupportedInstanceTypesCommand")
-    .sc(schemas_0.ListSupportedInstanceTypes$)
+    .sc(ListSupportedInstanceTypes$)
     .build() {
 }
 
-class ModifyClusterCommand extends client.Command
+class ModifyClusterCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "ModifyCluster", {})
     .n("EMRClient", "ModifyClusterCommand")
-    .sc(schemas_0.ModifyCluster$)
+    .sc(ModifyCluster$)
     .build() {
 }
 
-class ModifyInstanceFleetCommand extends client.Command
+class ModifyInstanceFleetCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "ModifyInstanceFleet", {})
     .n("EMRClient", "ModifyInstanceFleetCommand")
-    .sc(schemas_0.ModifyInstanceFleet$)
+    .sc(ModifyInstanceFleet$)
     .build() {
 }
 
-class ModifyInstanceGroupsCommand extends client.Command
+class ModifyInstanceGroupsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "ModifyInstanceGroups", {})
     .n("EMRClient", "ModifyInstanceGroupsCommand")
-    .sc(schemas_0.ModifyInstanceGroups$)
+    .sc(ModifyInstanceGroups$)
     .build() {
 }
 
-class PutAutoScalingPolicyCommand extends client.Command
+class PutAutoScalingPolicyCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "PutAutoScalingPolicy", {})
     .n("EMRClient", "PutAutoScalingPolicyCommand")
-    .sc(schemas_0.PutAutoScalingPolicy$)
+    .sc(PutAutoScalingPolicy$)
     .build() {
 }
 
-class PutAutoTerminationPolicyCommand extends client.Command
+class PutAutoTerminationPolicyCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "PutAutoTerminationPolicy", {})
     .n("EMRClient", "PutAutoTerminationPolicyCommand")
-    .sc(schemas_0.PutAutoTerminationPolicy$)
+    .sc(PutAutoTerminationPolicy$)
     .build() {
 }
 
-class PutBlockPublicAccessConfigurationCommand extends client.Command
+class PutBlockPublicAccessConfigurationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "PutBlockPublicAccessConfiguration", {})
     .n("EMRClient", "PutBlockPublicAccessConfigurationCommand")
-    .sc(schemas_0.PutBlockPublicAccessConfiguration$)
+    .sc(PutBlockPublicAccessConfiguration$)
     .build() {
 }
 
-class PutManagedScalingPolicyCommand extends client.Command
+class PutManagedScalingPolicyCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "PutManagedScalingPolicy", {})
     .n("EMRClient", "PutManagedScalingPolicyCommand")
-    .sc(schemas_0.PutManagedScalingPolicy$)
+    .sc(PutManagedScalingPolicy$)
     .build() {
 }
 
-class RemoveAutoScalingPolicyCommand extends client.Command
+class RemoveAutoScalingPolicyCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "RemoveAutoScalingPolicy", {})
     .n("EMRClient", "RemoveAutoScalingPolicyCommand")
-    .sc(schemas_0.RemoveAutoScalingPolicy$)
+    .sc(RemoveAutoScalingPolicy$)
     .build() {
 }
 
-class RemoveAutoTerminationPolicyCommand extends client.Command
+class RemoveAutoTerminationPolicyCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "RemoveAutoTerminationPolicy", {})
     .n("EMRClient", "RemoveAutoTerminationPolicyCommand")
-    .sc(schemas_0.RemoveAutoTerminationPolicy$)
+    .sc(RemoveAutoTerminationPolicy$)
     .build() {
 }
 
-class RemoveManagedScalingPolicyCommand extends client.Command
+class RemoveManagedScalingPolicyCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "RemoveManagedScalingPolicy", {})
     .n("EMRClient", "RemoveManagedScalingPolicyCommand")
-    .sc(schemas_0.RemoveManagedScalingPolicy$)
+    .sc(RemoveManagedScalingPolicy$)
     .build() {
 }
 
-class RemoveTagsCommand extends client.Command
+class RemoveTagsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "RemoveTags", {})
     .n("EMRClient", "RemoveTagsCommand")
-    .sc(schemas_0.RemoveTags$)
+    .sc(RemoveTags$)
     .build() {
 }
 
-class RunJobFlowCommand extends client.Command
+class RunJobFlowCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "RunJobFlow", {})
     .n("EMRClient", "RunJobFlowCommand")
-    .sc(schemas_0.RunJobFlow$)
+    .sc(RunJobFlow$)
     .build() {
 }
 
-class SetKeepJobFlowAliveWhenNoStepsCommand extends client.Command
+class SetKeepJobFlowAliveWhenNoStepsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "SetKeepJobFlowAliveWhenNoSteps", {})
     .n("EMRClient", "SetKeepJobFlowAliveWhenNoStepsCommand")
-    .sc(schemas_0.SetKeepJobFlowAliveWhenNoSteps$)
+    .sc(SetKeepJobFlowAliveWhenNoSteps$)
     .build() {
 }
 
-class SetTerminationProtectionCommand extends client.Command
+class SetTerminationProtectionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "SetTerminationProtection", {})
     .n("EMRClient", "SetTerminationProtectionCommand")
-    .sc(schemas_0.SetTerminationProtection$)
+    .sc(SetTerminationProtection$)
     .build() {
 }
 
-class SetUnhealthyNodeReplacementCommand extends client.Command
+class SetUnhealthyNodeReplacementCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "SetUnhealthyNodeReplacement", {})
     .n("EMRClient", "SetUnhealthyNodeReplacementCommand")
-    .sc(schemas_0.SetUnhealthyNodeReplacement$)
+    .sc(SetUnhealthyNodeReplacement$)
     .build() {
 }
 
-class SetVisibleToAllUsersCommand extends client.Command
+class SetVisibleToAllUsersCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "SetVisibleToAllUsers", {})
     .n("EMRClient", "SetVisibleToAllUsersCommand")
-    .sc(schemas_0.SetVisibleToAllUsers$)
+    .sc(SetVisibleToAllUsers$)
     .build() {
 }
 
-class StartNotebookExecutionCommand extends client.Command
+class StartNotebookExecutionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "StartNotebookExecution", {})
     .n("EMRClient", "StartNotebookExecutionCommand")
-    .sc(schemas_0.StartNotebookExecution$)
+    .sc(StartNotebookExecution$)
     .build() {
 }
 
-class StartSessionCommand extends client.Command
+class StartSessionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "StartSession", {})
     .n("EMRClient", "StartSessionCommand")
-    .sc(schemas_0.StartSession$)
+    .sc(StartSession$)
     .build() {
 }
 
-class StopNotebookExecutionCommand extends client.Command
+class StopNotebookExecutionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "StopNotebookExecution", {})
     .n("EMRClient", "StopNotebookExecutionCommand")
-    .sc(schemas_0.StopNotebookExecution$)
+    .sc(StopNotebookExecution$)
     .build() {
 }
 
-class TerminateJobFlowsCommand extends client.Command
+class TerminateJobFlowsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "TerminateJobFlows", {})
     .n("EMRClient", "TerminateJobFlowsCommand")
-    .sc(schemas_0.TerminateJobFlows$)
+    .sc(TerminateJobFlows$)
     .build() {
 }
 
-class TerminateSessionCommand extends client.Command
+class TerminateSessionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "TerminateSession", {})
     .n("EMRClient", "TerminateSessionCommand")
-    .sc(schemas_0.TerminateSession$)
+    .sc(TerminateSession$)
     .build() {
 }
 
-class UpdateStudioCommand extends client.Command
+class UpdateStudioCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "UpdateStudio", {})
     .n("EMRClient", "UpdateStudioCommand")
-    .sc(schemas_0.UpdateStudio$)
+    .sc(UpdateStudio$)
     .build() {
 }
 
-class UpdateStudioSessionMappingCommand extends client.Command
+class UpdateStudioSessionMappingCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("ElasticMapReduce", "UpdateStudioSessionMapping", {})
     .n("EMRClient", "UpdateStudioSessionMappingCommand")
-    .sc(schemas_0.UpdateStudioSessionMapping$)
+    .sc(UpdateStudioSessionMapping$)
     .build() {
 }
 
-const paginateListBootstrapActions = core.createPaginator(EMRClient, ListBootstrapActionsCommand, "Marker", "Marker", "");
+const paginateListBootstrapActions = createPaginator(EMRClient, ListBootstrapActionsCommand, "Marker", "Marker", "");
 
-const paginateListClusters = core.createPaginator(EMRClient, ListClustersCommand, "Marker", "Marker", "");
+const paginateListClusters = createPaginator(EMRClient, ListClustersCommand, "Marker", "Marker", "");
 
-const paginateListInstanceFleets = core.createPaginator(EMRClient, ListInstanceFleetsCommand, "Marker", "Marker", "");
+const paginateListInstanceFleets = createPaginator(EMRClient, ListInstanceFleetsCommand, "Marker", "Marker", "");
 
-const paginateListInstanceGroups = core.createPaginator(EMRClient, ListInstanceGroupsCommand, "Marker", "Marker", "");
+const paginateListInstanceGroups = createPaginator(EMRClient, ListInstanceGroupsCommand, "Marker", "Marker", "");
 
-const paginateListInstances = core.createPaginator(EMRClient, ListInstancesCommand, "Marker", "Marker", "");
+const paginateListInstances = createPaginator(EMRClient, ListInstancesCommand, "Marker", "Marker", "");
 
-const paginateListNotebookExecutions = core.createPaginator(EMRClient, ListNotebookExecutionsCommand, "Marker", "Marker", "");
+const paginateListNotebookExecutions = createPaginator(EMRClient, ListNotebookExecutionsCommand, "Marker", "Marker", "");
 
-const paginateListReleaseLabels = core.createPaginator(EMRClient, ListReleaseLabelsCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListReleaseLabels = createPaginator(EMRClient, ListReleaseLabelsCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListSecurityConfigurations = core.createPaginator(EMRClient, ListSecurityConfigurationsCommand, "Marker", "Marker", "");
+const paginateListSecurityConfigurations = createPaginator(EMRClient, ListSecurityConfigurationsCommand, "Marker", "Marker", "");
 
-const paginateListSessions = core.createPaginator(EMRClient, ListSessionsCommand, "NextToken", "NextToken", "");
+const paginateListSessions = createPaginator(EMRClient, ListSessionsCommand, "NextToken", "NextToken", "");
 
-const paginateListSteps = core.createPaginator(EMRClient, ListStepsCommand, "Marker", "Marker", "");
+const paginateListSteps = createPaginator(EMRClient, ListStepsCommand, "Marker", "Marker", "");
 
-const paginateListStudioSessionMappings = core.createPaginator(EMRClient, ListStudioSessionMappingsCommand, "Marker", "Marker", "");
+const paginateListStudioSessionMappings = createPaginator(EMRClient, ListStudioSessionMappingsCommand, "Marker", "Marker", "");
 
-const paginateListStudios = core.createPaginator(EMRClient, ListStudiosCommand, "Marker", "Marker", "");
+const paginateListStudios = createPaginator(EMRClient, ListStudiosCommand, "Marker", "Marker", "");
 
-const paginateListSupportedInstanceTypes = core.createPaginator(EMRClient, ListSupportedInstanceTypesCommand, "Marker", "Marker", "");
+const paginateListSupportedInstanceTypes = createPaginator(EMRClient, ListSupportedInstanceTypesCommand, "Marker", "Marker", "");
 
-const checkState$2 = async (client$1, input) => {
+const checkState$2 = async (client, input) => {
     let reason;
     try {
-        let result = await client$1.send(new DescribeClusterCommand(input));
+        let result = await client.send(new DescribeClusterCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.Cluster.Status.State;
             };
             if (returnComparator() === "RUNNING") {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -933,7 +936,7 @@ const checkState$2 = async (client$1, input) => {
                 return result.Cluster.Status.State;
             };
             if (returnComparator() === "WAITING") {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -942,7 +945,7 @@ const checkState$2 = async (client$1, input) => {
                 return result.Cluster.Status.State;
             };
             if (returnComparator() === "TERMINATING") {
-                return { state: client.WaiterState.FAILURE, reason };
+                return { state: WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -951,7 +954,7 @@ const checkState$2 = async (client$1, input) => {
                 return result.Cluster.Status.State;
             };
             if (returnComparator() === "TERMINATED") {
-                return { state: client.WaiterState.FAILURE, reason };
+                return { state: WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -960,7 +963,7 @@ const checkState$2 = async (client$1, input) => {
                 return result.Cluster.Status.State;
             };
             if (returnComparator() === "TERMINATED_WITH_ERRORS") {
-                return { state: client.WaiterState.FAILURE, reason };
+                return { state: WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -968,29 +971,29 @@ const checkState$2 = async (client$1, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForClusterRunning = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 120 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
 };
 const waitUntilClusterRunning = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 120 };
-    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 DescribeClusterCommand(input));
+        let result = await client.send(new DescribeClusterCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.Cluster.Status.State;
             };
             if (returnComparator() === "TERMINATED") {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -999,7 +1002,7 @@ const checkState$1 = async (client$1, input) => {
                 return result.Cluster.Status.State;
             };
             if (returnComparator() === "TERMINATED_WITH_ERRORS") {
-                return { state: client.WaiterState.FAILURE, reason };
+                return { state: WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -1007,29 +1010,29 @@ const checkState$1 = async (client$1, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForClusterTerminated = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 120 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
 };
 const waitUntilClusterTerminated = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 120 };
-    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 DescribeStepCommand(input));
+        let result = await client.send(new DescribeStepCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.Step.Status.State;
             };
             if (returnComparator() === "COMPLETED") {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1038,7 +1041,7 @@ const checkState = async (client$1, input) => {
                 return result.Step.Status.State;
             };
             if (returnComparator() === "FAILED") {
-                return { state: client.WaiterState.FAILURE, reason };
+                return { state: WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -1047,7 +1050,7 @@ const checkState = async (client$1, input) => {
                 return result.Step.Status.State;
             };
             if (returnComparator() === "CANCELLED") {
-                return { state: client.WaiterState.FAILURE, reason };
+                return { state: WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -1055,16 +1058,16 @@ const checkState = async (client$1, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForStepComplete = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 120 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
 const waitUntilStepComplete = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 120 };
-    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 = {
@@ -1156,7 +1159,7 @@ const waiters = {
 };
 class EMR extends EMRClient {
 }
-client.createAggregatedClient(commands, EMR, { paginators, waiters });
+createAggregatedClient(commands, EMR, { paginators, waiters });
 
 const ActionOnFailure = {
     CANCEL_AND_WAIT: "CANCEL_AND_WAIT",
@@ -1472,9 +1475,6 @@ const ReconfigurationType = {
     OVERWRITE: "OVERWRITE",
 };
 
-exports.$Command = client.Command;
-exports.__Client = client.Client;
-exports.EMRServiceException = EMRServiceException.EMRServiceException;
 exports.ActionOnFailure = ActionOnFailure;
 exports.AddInstanceFleetCommand = AddInstanceFleetCommand;
 exports.AddInstanceGroupsCommand = AddInstanceGroupsCommand;
@@ -1610,23 +1610,3 @@ exports.waitForStepComplete = waitForStepComplete;
 exports.waitUntilClusterRunning = waitUntilClusterRunning;
 exports.waitUntilClusterTerminated = waitUntilClusterTerminated;
 exports.waitUntilStepComplete = waitUntilStepComplete;
-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];
-});